text
stringlengths 3
1.05M
|
|---|
from functools import wraps
from django.conf import settings
from django.contrib.auth import get_user_model
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models as django_models
from django.db import transaction
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from django_fsm import FSMIntegerField
from model_utils.models import TimeStampedModel
from rest_framework import response, status
from waldur_core.core import models
User = get_user_model()
def ensure_atomic_transaction(func):
@wraps(func)
def wrapped(self, *args, **kwargs):
if settings.WALDUR_CORE['USE_ATOMIC_TRANSACTION']:
with transaction.atomic():
return func(self, *args, **kwargs)
else:
return func(self, *args, **kwargs)
return wrapped
class AsyncExecutor:
async_executor = True
class CreateExecutorMixin(AsyncExecutor):
create_executor = NotImplemented
@ensure_atomic_transaction
def perform_create(self, serializer):
instance = serializer.save()
self.create_executor.execute(instance, is_async=self.async_executor)
instance.refresh_from_db()
class UpdateExecutorMixin(AsyncExecutor):
update_executor = NotImplemented
def get_update_executor_kwargs(self, serializer):
return {}
@ensure_atomic_transaction
def perform_update(self, serializer):
instance = self.get_object()
# Save all instance fields before update.
# To avoid additional DB queries - store foreign keys as ids.
# Warning! M2M fields will be ignored.
before_update_fields = {
f: getattr(instance, f.attname) for f in instance._meta.fields
}
super(UpdateExecutorMixin, self).perform_update(serializer)
instance.refresh_from_db()
updated_fields = {
f.name
for f, v in before_update_fields.items()
if v != getattr(instance, f.attname)
}
kwargs = self.get_update_executor_kwargs(serializer)
self.update_executor.execute(
instance,
is_async=self.async_executor,
updated_fields=updated_fields,
**kwargs
)
serializer.instance.refresh_from_db()
class DeleteExecutorMixin(AsyncExecutor):
delete_executor = NotImplemented
@ensure_atomic_transaction
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
self.delete_executor.execute(
instance,
is_async=self.async_executor,
force=instance.state == models.StateMixin.States.ERRED,
)
return response.Response(
{'detail': _('Deletion was scheduled.')}, status=status.HTTP_202_ACCEPTED
)
class ExecutorMixin(CreateExecutorMixin, UpdateExecutorMixin, DeleteExecutorMixin):
"""Execute create/update/delete operation with executor"""
pass
class EagerLoadMixin:
"""Reduce number of requests to DB.
Serializer should implement static method "eager_load", that selects
objects that are necessary for serialization.
"""
def get_queryset(self):
queryset = super(EagerLoadMixin, self).get_queryset()
serializer_class = self.get_serializer_class()
if self.action in ('list', 'retrieve') and hasattr(
serializer_class, 'eager_load'
):
queryset = serializer_class.eager_load(queryset, self.request)
return queryset
class ScopeMixin(django_models.Model):
class Meta:
abstract = True
content_type = django_models.ForeignKey(
to=ContentType,
on_delete=django_models.CASCADE,
null=True,
blank=True,
related_name='+',
)
object_id = django_models.PositiveIntegerField(null=True, blank=True)
scope = GenericForeignKey('content_type', 'object_id')
class ReviewStateMixin(django_models.Model):
class Meta:
abstract = True
class States:
DRAFT = 1
PENDING = 2
APPROVED = 3
REJECTED = 4
CANCELED = 5
CHOICES = (
(DRAFT, 'draft'),
(PENDING, 'pending'),
(APPROVED, 'approved'),
(REJECTED, 'rejected'),
(CANCELED, 'canceled'),
)
state = FSMIntegerField(default=States.DRAFT, choices=States.CHOICES)
def submit(self):
self.state = self.States.PENDING
self.save(update_fields=['state'])
def cancel(self):
self.state = self.States.CANCELED
self.save(update_fields=['state'])
class ReviewMixin(ReviewStateMixin, TimeStampedModel):
class Meta:
abstract = True
reviewed_by = django_models.ForeignKey(
on_delete=django_models.CASCADE,
to=User,
null=True,
blank=True,
related_name='+',
)
reviewed_at = django_models.DateTimeField(editable=False, null=True, blank=True)
review_comment = django_models.TextField(null=True, blank=True)
@transaction.atomic
def approve(self, user, comment=None):
self.reviewed_by = user
self.review_comment = comment
self.reviewed_at = timezone.now()
self.state = self.States.APPROVED
self.save(
update_fields=['reviewed_by', 'reviewed_at', 'review_comment', 'state']
)
@transaction.atomic
def reject(self, user, comment=None):
self.reviewed_by = user
self.review_comment = comment
self.reviewed_at = timezone.now()
self.state = self.States.REJECTED
self.save(
update_fields=['reviewed_by', 'reviewed_at', 'review_comment', 'state']
)
@property
def is_rejected(self):
return self.state == self.States.REJECTED
|
import os
import sys
import subprocess
import traceback
try:
sys.path.append(snakemake.config['args']['mcc_path'])
import scripts.mccutils as mccutils
except Exception as e:
track = traceback.format_exc()
print(track, file=sys.stderr)
print("ERROR...unable to locate required external scripts at: "+snakemake.config['args']['mcc_path']+"/scripts/", file=sys.stderr)
sys.exit(1)
def main():
log = snakemake.params.log
mccutils.log("processing","Converting sam to bam", log=log)
try:
command = ["samtools","view", "-@", str(snakemake.threads), "-Sb", "-t", snakemake.input.ref_idx, snakemake.input.sam]
mccutils.run_command_stdout(command, snakemake.output.tmp_bam, log=log)
mccutils.check_file_exists(snakemake.output.tmp_bam)
except Exception as e:
track = traceback.format_exc()
print(track, file=sys.stderr)
print("ERROR...unable convert sam to bam using SAMtools...sam file:", snakemake.input.sam, file=sys.stderr)
sys.exit(1)
try:
command = ["samtools", "sort", "-@", str(snakemake.threads), snakemake.output.tmp_bam, snakemake.output.bam.replace(".bam", "")]
mccutils.run_command(command, log=log)
mccutils.check_file_exists(snakemake.output.bam)
except Exception as e:
track = traceback.format_exc()
print(track, file=sys.stderr)
print("ERROR...falied to sort the bam file using samtools sort...bam file:", snakemake.output.tmp_bam, file=sys.stderr)
sys.exit(1)
try:
command = ["samtools", "index", snakemake.output.bam]
mccutils.run_command(command, log=log)
except Exception as e:
track = traceback.format_exc()
print(track, file=sys.stderr)
print("ERROR...falied to index the bam file using samtools index...bam file:", snakemake.output.bam, file=sys.stderr)
sys.exit(1)
try:
command = ["samtools", "flagstat", snakemake.output.bam]
mccutils.run_command_stdout(command, snakemake.output.flagstat, log=log)
mccutils.check_file_exists(snakemake.output.flagstat)
except Exception as e:
track = traceback.format_exc()
print(track, file=sys.stderr)
print("ERROR...falied to generate flagstat file using samtools flagstat...bam file:", snakemake.output.bam, file=sys.stderr)
sys.exit(1)
mccutils.log("processing","sam to bam converted")
if __name__ == "__main__":
main() |
from allenact_plugins.ithor_plugin.ithor_sensors import GoalObjectTypeThorSensor
from allenact_plugins.robothor_plugin.robothor_sensors import DepthSensorThor
from projects.objectnav_baselines.experiments.ithor.objectnav_ithor_base import (
ObjectNaviThorBaseConfig,
)
from projects.objectnav_baselines.experiments.objectnav_mixin_ddppo import (
ObjectNavMixInPPOConfig,
)
from projects.objectnav_baselines.experiments.objectnav_mixin_resnetgru import (
ObjectNavMixInResNetGRUConfig,
)
class ObjectNavRoboThorRGBPPOExperimentConfig(
ObjectNaviThorBaseConfig, ObjectNavMixInPPOConfig, ObjectNavMixInResNetGRUConfig,
):
"""An Object Navigation experiment configuration in iThor with Depth
input."""
SENSORS = (
DepthSensorThor(
height=ObjectNaviThorBaseConfig.SCREEN_SIZE,
width=ObjectNaviThorBaseConfig.SCREEN_SIZE,
use_normalization=True,
uuid="depth_lowres",
),
GoalObjectTypeThorSensor(object_types=ObjectNaviThorBaseConfig.TARGET_TYPES,),
)
@classmethod
def tag(cls):
return "Objectnav-iTHOR-Depth-ResNetGRU-DDPPO"
|
/*global describe,beforeEach,it,expect */
var SandboxedModule = require('sandboxed-module');
var Command = require("commander").Command;
describe("spec template", function () {
var testCommand;
var Template;
beforeEach(function() {
Template = SandboxedModule.require('../../templates/spec', {
requires: {
'../lib/template-base': {
TemplateBase: {
addOptions: function(command) {
return command;
}
}
}
}
}).Template;
testCommand = new Command();
});
it("should have a commandDescription defined on prototype", function () {
expect(Template.commandDescription).toBeDefined();
});
it("should return the command from addOptions", function () {
expect(Object.create(Template).addOptions(testCommand)).toBe(testCommand);
});
describe("command", function () {
it("should have --name option", function () {
var command = Object.create(Template).addOptions(testCommand);
expect(command.optionFor("-n")).toBeDefined();
expect(command.optionFor("--name")).toBeDefined();
});
it("should have --title option", function () {
var command = Object.create(Template).addOptions(testCommand);
expect(command.optionFor("-t")).toBeDefined();
expect(command.optionFor("--title")).toBeDefined();
});
});
describe("option validation", function () {
var template;
var options;
beforeEach(function () {
template = Object.create(Template);
options = {};
});
it("should accept name with dashes", function () {
options.name = "my-component";
template.didSetOptions(options);
expect(options.name).toEqual("my-component");
expect(options.title).toEqual("MyComponent");
});
});
}); |
import * as Curry from "../../../../../../../../../../../../node_modules/bs-platform/lib/es6/curry.js";
import * as AppStore$WonderEditor from "../../../../../../../../ui/store/AppStore.js";
import * as EventHandler$WonderEditor from "../../../../../../../../ui/eventHandler/EventHandler.js";
import * as EmptyEventHandler$WonderEditor from "../../../../../../../../ui/eventHandler/EmptyEventHandler.js";
import * as StateLogicService$WonderEditor from "../../../../../../../../../service/stateTuple/logic/StateLogicService.js";
import * as SceneEngineService$WonderEditor from "../../../../../../../../../service/state/engine/SceneEngineService.js";
import * as StateEditorService$WonderEditor from "../../../../../../../../../service/state/editor/StateEditorService.js";
import * as StateEngineService$WonderEditor from "../../../../../../../../../service/state/engine/state/StateEngineService.js";
import * as AddableComponentUtils$WonderEditor from "../utils/AddableComponentUtils.js";
import * as InspectorRemoveComponentUtils$WonderEditor from "../../../../utils/InspectorRemoveComponentUtils.js";
var setUndoValueToCopiedEngineState = EmptyEventHandler$WonderEditor.EmptyEventHandler[1];
var setUndoValueToCopiedEngineStateForPromise = EmptyEventHandler$WonderEditor.EmptyEventHandler[2];
function _isRemoveLight(type_) {
return type_ === /* Light */5;
}
function handleSelfLogic(param, currentSceneTreeNode, type_) {
var dispatchFunc = param[1];
var match = InspectorRemoveComponentUtils$WonderEditor.removeComponentByType(type_, currentSceneTreeNode, /* tuple */[
StateEditorService$WonderEditor.getState(/* () */0),
StateEngineService$WonderEditor.unsafeGetState(/* () */0)
]);
StateEditorService$WonderEditor.setState(match[0]);
StateEngineService$WonderEditor.setState(match[1]);
var match$1 = type_ === /* Light */5;
if (match$1) {
StateLogicService$WonderEditor.getAndRefreshEngineState(/* () */0);
StateLogicService$WonderEditor.getAndSetEngineState(SceneEngineService$WonderEditor.clearShaderCacheAndReInitAllLightMaterials);
}
StateLogicService$WonderEditor.getAndRefreshEngineState(/* () */0);
var match$2 = AddableComponentUtils$WonderEditor.isNeedUpdateSceneTree(type_);
if (match$2) {
Curry._1(dispatchFunc, [
AppStore$WonderEditor.UpdateAction,
/* Update */[/* array */[
/* Inspector */2,
/* SceneTree */6
]]
]);
return /* () */0;
} else {
Curry._1(dispatchFunc, [
AppStore$WonderEditor.UpdateAction,
/* Update */[/* array */[/* Inspector */2]]
]);
return /* () */0;
}
}
var CustomEventHandler = /* module */[
/* setUndoValueToCopiedEngineState */setUndoValueToCopiedEngineState,
/* setUndoValueToCopiedEngineStateForPromise */setUndoValueToCopiedEngineStateForPromise,
/* _isRemoveLight */_isRemoveLight,
/* handleSelfLogic */handleSelfLogic
];
var MakeEventHandler = EventHandler$WonderEditor.MakeEventHandler([
handleSelfLogic,
setUndoValueToCopiedEngineState,
setUndoValueToCopiedEngineStateForPromise
]);
export {
CustomEventHandler ,
MakeEventHandler ,
}
/* MakeEventHandler Not a pure module */
|
export default function CapsLock(props) {
const textoInserido = props.texto
const textoEmCapsLock = textoInserido.toUpperCase()
const childrenInserido = props.children
const childrenEmCapsLock = childrenInserido.toUpperCase()
return (
<div>
<div>{textoEmCapsLock} - {childrenEmCapsLock}</div>
</div>
)
}
|
"""
WSGI config for notebook project.
This module contains the WSGI application used by Django's development server
and any production WSGI deployments. It should expose a module-level variable
named ``application``. Django's ``runserver`` and ``runfcgi`` commands discover
this application via the ``WSGI_APPLICATION`` setting.
Usually you will have the standard Django WSGI application here, but it also
might make sense to replace the whole Django WSGI application with a custom one
that later delegates to the Django one. For example, you could introduce WSGI
middleware here, or combine a Django application with an application of another
framework.
"""
import os
import sys
from pathlib import Path
from django.core.wsgi import get_wsgi_application
# This allows easy placement of apps within the interior
# notebook directory.
ROOT_DIR = Path(__file__).resolve(strict=True).parent.parent
sys.path.append(str(ROOT_DIR / "notebook"))
# We defer to a DJANGO_SETTINGS_MODULE already in the environment. This breaks
# if running multiple sites in the same mod_wsgi process. To fix this, use
# mod_wsgi daemon mode with each site in its own daemon process, or use
# os.environ["DJANGO_SETTINGS_MODULE"] = "config.settings.production"
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.production")
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
application = get_wsgi_application()
# Apply WSGI middleware here.
# from helloworld.wsgi import HelloWorldApplication
# application = HelloWorldApplication(application)
|
import json
from util.config import APIDOC_DESCRIPTION_STORE_PATH, JAVADOC_GLOBAL_NAME, INITIAL_API_DOMAIN_TERM_MAP_STORE_PATH, API_DOMAIN_TERM_STORE_PATH, FUSED_API_DOMAIN_TERM_MAP_STORE_PATH, FUSED_DOMAIN_TERM_API_MAP_STORE_PATH, FUSED_DOMAIN_TERM_STORE_PATH
def generate_fused_api_term_map(doc_name: str = JAVADOC_GLOBAL_NAME):
with open(FUSED_DOMAIN_TERM_STORE_PATH[doc_name], 'r', encoding='utf-8') as rf:
fused_term_to_aliases_map = json.load(rf)
fused_alias_to_term_map = {}
for k, aliases in fused_term_to_aliases_map.items():
for alias in aliases:
fused_alias_to_term_map[alias] = k
print('len of whole initially fused terms: ',
len(fused_term_to_aliases_map.keys()))
with open(INITIAL_API_DOMAIN_TERM_MAP_STORE_PATH[doc_name], 'r', encoding='utf-8') as rf:
initial_api_term_map = json.load(rf)
fused_term_to_api_map = {}
fused_api_to_term_map = {}
for api_name, initial_terms in initial_api_term_map.items():
correspond_fused_terms = set()
for term in initial_terms:
correspond_fused_term = fused_alias_to_term_map.get(term, None)
if correspond_fused_term is not None:
correspond_fused_terms.add(correspond_fused_term)
fused_api_to_term_map[api_name] = list(correspond_fused_terms)
for term in correspond_fused_terms:
if term in fused_term_to_api_map:
fused_term_to_api_map[term].append(api_name)
else:
fused_term_to_api_map[term] = [api_name]
with open(FUSED_API_DOMAIN_TERM_MAP_STORE_PATH[doc_name], 'w', encoding='utf-8') as wf_api_term, open(FUSED_DOMAIN_TERM_API_MAP_STORE_PATH[doc_name], 'w', encoding='utf-8') as wf_term_api:
json.dump(fused_api_to_term_map, wf_api_term,
ensure_ascii=False, indent=2)
json.dump(fused_term_to_api_map, wf_term_api,
ensure_ascii=False, indent=2)
if __name__ == "__main__":
generate_fused_api_term_map()
|
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
number=['1','2','3']
from cipher_art import logo
print(logo)
def ceacer (ctext,cshift,cdirection):
final_text=""
if cdirection=="decode":
cshift*=-1
for letter in ctext:
if letter in alphabet:
pos=alphabet.index(letter)
newpos=pos+cshift
final_text+=alphabet[newpos]
else:
final_text+=letter
print(f"Here is the {cdirection}d result {final_text}")
true=True
while true:
direction = input("Type 'encode' to encrypt, type 'decode' to decrypt:\n")
if direction== "encode" or direction=="decode":
text = input("Type your message:\n").lower()
shift = int(input("Type the shift number:\n"))
shift=shift%26
else:
print ("invalid")
exit()
ceacer(ctext=text,cdirection=direction,cshift=shift)
cont=input("do you want to start again(yes/No)=").lower()
if cont=="no":
true=False
|
import numpy as np
import collections
from types import SimpleNamespace
from typing import Tuple
from affine import Affine
# This is numeric code, short names make sense in this context, so disabling
# "invalid name" checks for the whole file
# pylint: disable=invalid-name
class WindowFromSlice(object):
""" Translate numpy slices (numpy.s_) to rasterio window tuples.
"""
def __getitem__(self, roi):
if roi is None:
return None
if not isinstance(roi, collections.Sequence) or len(roi) != 2:
raise ValueError("Need 2d roi")
row, col = roi
return ((0 if row.start is None else row.start, row.stop),
(0 if col.start is None else col.start, col.stop))
w_ = WindowFromSlice()
def polygon_path(x, y=None):
"""A little bit like numpy.meshgrid, except returns only boundary values and
limited to 2d case only.
Examples:
[0,1], [3,4] =>
array([[0, 1, 1, 0, 0],
[3, 3, 4, 4, 3]])
[0,1] =>
array([[0, 1, 1, 0, 0],
[0, 0, 1, 1, 0]])
"""
if y is None:
y = x
return np.vstack([
np.vstack([x, np.full_like(x, y[0])]).T,
np.vstack([np.full_like(y, x[-1]), y]).T[1:],
np.vstack([x, np.full_like(x, y[-1])]).T[::-1][1:],
np.vstack([np.full_like(y, x[0]), y]).T[::-1][1:]]).T
def gbox_boundary(gbox, pts_per_side=16):
"""Return points in pixel space along the perimeter of a GeoBox, or a 2d array.
"""
H, W = gbox.shape[:2]
xx = np.linspace(0, W, pts_per_side, dtype='float32')
yy = np.linspace(0, H, pts_per_side, dtype='float32')
return polygon_path(xx, yy).T[:-1]
def roi_boundary(roi, pts_per_side=2):
"""
Get boundary points from a 2d roi.
roi needs to be in the normalised form, i.e. no open-ended start/stop, see roi_normalise
:returns: Nx2 float32 array of X,Y points on the perimeter of the envelope defined by `roi`
"""
yy, xx = roi
xx = np.linspace(xx.start, xx.stop, pts_per_side, dtype='float32')
yy = np.linspace(yy.start, yy.stop, pts_per_side, dtype='float32')
return polygon_path(xx, yy).T[:-1]
def align_down(x, align):
return x - (x % align)
def align_up(x, align):
return align_down(x+(align-1), align)
def scaled_down_roi(roi, scale: int):
return tuple(slice(s.start//scale,
align_up(s.stop, scale)//scale) for s in roi)
def scaled_up_roi(roi, scale: int, shape=None):
roi = tuple(slice(s.start*scale,
s.stop*scale) for s in roi)
if shape is not None:
roi = tuple(slice(min(dim, s.start),
min(dim, s.stop))
for s, dim in zip(roi, shape))
return roi
def scaled_down_shape(shape, scale: int):
return tuple(align_up(s, scale)//scale for s in shape)
def roi_shape(roi):
def slice_dim(s):
return s.stop if s.start is None else s.stop - s.start
if isinstance(roi, slice):
roi = (roi,)
return tuple(slice_dim(s) for s in roi)
def roi_is_empty(roi):
return any(d <= 0 for d in roi_shape(roi))
def roi_is_full(roi, shape):
"""
:returns: True if roi covers region from (0,..) -> shape
"""
def slice_full(s, n):
return s.start in (0, None) and s.stop in (n, None)
if isinstance(roi, slice):
roi = (roi,)
shape = (shape,)
return all(slice_full(s, n) for s, n in zip(roi, shape))
def roi_normalise(roi, shape):
"""
Fill in missing .start/.stop, also deal with negative values, which are
treated as offsets from the end.
.step parameter is left unchanged.
Example:
np.s_[:3, 4: ], (10, 20) -> np._s[0:3, 4:20]
np.s_[:3, :-3], (10, 20) -> np._s[0:3, 0:17]
"""
def fill_if_none(x, val_if_none):
return val_if_none if x is None else x
def norm_slice(s, n):
start = fill_if_none(s.start, 0)
stop = fill_if_none(s.stop, n)
start, stop = [x if x >= 0 else n+x for x in (start, stop)]
return slice(start, stop, s.step)
if not isinstance(shape, collections.Sequence):
shape = (shape,)
if isinstance(roi, slice):
return norm_slice(roi, shape[0])
return tuple([norm_slice(s, n) for s, n in zip(roi, shape)])
def roi_pad(roi, pad, shape):
"""
Pad ROI on each side, with clamping (0,..) -> shape
"""
def pad_slice(s, n):
return slice(max(0, s.start - pad), min(n, s.stop + pad))
if isinstance(roi, slice):
return pad_slice(roi, shape)
return tuple(pad_slice(s, n) for s, n in zip(roi, shape))
def apply_affine(A: Affine, x: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
"""
broadcast A*(x_i, y_i) across all elements of x/y arrays in any shape (usually 2d image)
"""
shape = x.shape
A = np.asarray(A).reshape(3, 3)
t = A[:2, -1].reshape((2, 1))
A = A[:2, :2]
x, y = A @ np.vstack([x.ravel(), y.ravel()]) + t
x, y = (a.reshape(shape) for a in (x, y))
return (x, y)
def split_translation(t):
"""
Split translation into pixel aligned and sub-pixel components.
Subpixel translation is guaranteed to be in [-0.5, +0.5] range.
> x + t = x + t_whole + t_subpix
:param t: (float, float)
:returns: (t_whole: (float, float), t_subpix: (float, float))
"""
from math import fmod
def _split1(x):
x_part = fmod(x, 1.0)
x_whole = x - x_part
if x_part > 0.5:
x_part -= 1
x_whole += 1
elif x_part < -0.5:
x_part += 1
x_whole -= 1
return (x_whole, x_part)
_tt = [_split1(x) for x in t]
return tuple(t[0] for t in _tt), tuple(t[1] for t in _tt)
def is_affine_st(A, tol=1e-10):
"""
True if Affine transform has scale and translation components only.
"""
(_, wx, _,
wy, _, _,
*_) = A
return abs(wx) < tol and abs(wy) < tol
def decompose_rws(A):
"""
Compute decomposition Affine matrix sans translation into Rotation, Shear and Scale.
Note: that there are ambiguities for negative scales.
Example: R(90)*S(1,1) == R(-90)*S(-1,-1),
(R*(-I))*((-I)*S) == R*S
A = R W S
Where:
R [ca -sa] W [1, w] S [sx, 0]
[sa ca] [0, 1] [ 0, sy]
:return: Rotation, Sheer, Scale
"""
# pylint: disable=too-many-locals
from numpy.linalg import cholesky, det, inv
if isinstance(A, Affine):
def to_affine(m, t=(0, 0)):
a, b, d, e = m.ravel()
c, f = t
return Affine(a, b, c,
d, e, f)
(a, b, c,
d, e, f,
*_) = A
R, W, S = decompose_rws(np.asarray([[a, b],
[d, e]], dtype='float64'))
return to_affine(R, (c, f)), to_affine(W), to_affine(S)
assert A.shape == (2, 2)
WS = cholesky(A.T @ A).T
R = A @ inv(WS)
if det(R) < 0:
R[:, -1] *= -1
WS[-1, :] *= -1
ss = np.diag(WS)
S = np.diag(ss)
W = WS @ np.diag(1.0/ss)
return R, W, S
def affine_from_pts(X, Y):
"""
Given points X,Y compute A, such that: Y = A*X.
Needs at least 3 points.
:rtype: Affine
"""
from numpy.linalg import lstsq
assert len(X) == len(Y)
assert len(X) >= 3
n = len(X)
XX = np.ones((n, 3), dtype='float64')
YY = np.vstack(Y)
for i, x in enumerate(X):
XX[i, :2] = x
mm, *_ = lstsq(XX, YY, rcond=-1)
a, d, b, e, c, f = mm.ravel()
return Affine(a, b, c,
d, e, f)
def get_scale_from_linear_transform(A):
"""
Given a linear transform compute scale change.
1. Y = A*X + t
2. Extract scale components of A
Returns (sx, sy), where sx > 0, sy > 0
"""
_, _, S = decompose_rws(A)
return abs(S.a), abs(S.e)
def get_scale_at_point(pt, tr, r=None):
"""
Given an arbitrary locally linear transform estimate scale change around a point.
1. Approximate Y = tr(X) as Y = A*X+t in the neighbourhood of pt, for X,Y in R2
2. Extract scale components of A
pt - estimate transform around this point
r - radius around the point (default 1)
tr - List((x,y)) -> List((x,y))
takes list of 2-d points on input and outputs same length list of 2d on output
Returns (sx, sy), where sx > 0, sy > 0
"""
pts0 = [(0, 0), (-1, 0), (0, -1), (1, 0), (0, 1)]
x0, y0 = pt
if r is None:
XX = [(float(x+x0), float(y+y0)) for x, y in pts0]
else:
XX = [(float(x*r+x0), float(y*r+y0)) for x, y in pts0]
YY = tr(XX)
A = affine_from_pts(XX, YY)
return get_scale_from_linear_transform(A)
def _same_crs_pix_transform(src, dst):
assert src.crs == dst.crs
def transorm(pts, A):
return [A*pt[:2] for pt in pts]
_fwd = (~dst.transform) * src.transform # src -> dst
_bwd = ~_fwd # dst -> src
def pt_tr(pts):
return transorm(pts, _fwd)
pt_tr.back = lambda pts: transorm(pts, _bwd)
pt_tr.back.back = pt_tr
pt_tr.linear = _fwd
pt_tr.back.linear = _bwd
return pt_tr
def compute_axis_overlap(Ns: int, Nd: int, s: float, t: float) -> Tuple[slice, slice]:
"""
s, t define linear transform from destination coordinate space to source
>> x_s = s * x_d + t
Ns -- number of pixels along some dimension of source image: (0, Ns)
Nd -- same as Ns but for destination image
:returns: (slice in the source image,
slice in the destination image)
"""
from math import floor, ceil
needs_flip = s < 0
if needs_flip:
# change s, t to map into flipped src, i.e. src[::-1]
s, t = -s, Ns - t
assert s > 0
# x_d = (x_s - t)/s => 1/s * x_s + t*(-1/s)
#
# x_d = s_ * x_s + t_
s_ = 1.0/s
t_ = -t*s_
if t < 0:
# |<------- ... D
# |<--- ... S
_in = (0, min(floor(t_), Nd))
else:
# |<--... D
# |<---------... S
_in = (min(floor(t), Ns), 0)
a = ceil(Nd*s + t)
if a <= Ns:
# ...----->| D
# ...-------->| S
_out = (max(a, 0), Nd)
else:
# ...-------->| D
# ...----->| S
_out = (Ns, max(0, ceil(Ns*s_ + t_)))
src, dst = (slice(_in[i], _out[i]) for i in range(2))
if needs_flip:
# remap src from flipped space to normal
src = slice(Ns - src.stop, Ns - src.start) # type: ignore
return (src, dst)
def box_overlap(src_shape, dst_shape, ST):
"""
Given two image planes whose coordinate systems are related via scale and
translation only, find overlapping regions within both.
:param src_shape: Shape of source image plane
:param dst_shape: Shape of destination image plane
:param ST: Affine transform with only scale/translation,
direction is: Xsrc = ST*Xdst
"""
(sx, _, tx,
_, sy, ty,
*_) = ST
s0, d0 = compute_axis_overlap(src_shape[0], dst_shape[0], sy, ty)
s1, d1 = compute_axis_overlap(src_shape[1], dst_shape[1], sx, tx)
return (s0, s1), (d0, d1)
def native_pix_transform(src, dst):
"""
direction: from src to dst
.back: goes the other way
.linear: None|Affine linear transform src->dst if transform is linear (i.e. same CRS)
"""
from ._base import mk_osr_point_transform
# Special case CRS_in == CRS_out
if src.crs == dst.crs:
return _same_crs_pix_transform(src, dst)
_in = SimpleNamespace(crs=src.crs, A=src.transform)
_out = SimpleNamespace(crs=dst.crs, A=dst.transform)
_fwd = mk_osr_point_transform(_in.crs, _out.crs)
_bwd = mk_osr_point_transform(_out.crs, _in.crs)
_fwd = (_in.A, _fwd, ~_out.A)
_bwd = (_out.A, _bwd, ~_in.A)
def transform(pts, params):
A, f, B = params
return [B*pt[:2] for pt in f.TransformPoints([A*pt[:2] for pt in pts])]
def tr(pts):
return transform(pts, _fwd)
tr.back = lambda pts: transform(pts, _bwd)
tr.back.back = tr
tr.linear = None
tr.back.linear = None
return tr
def roi_intersect(a, b):
"""
Compute intersection of two ROIs
"""
def slice_intersect(a, b):
if a.stop < b.start:
return slice(a.stop, a.stop)
elif a.start > b.stop:
return slice(a.start, a.start)
_in = max(a.start, b.start)
_out = min(a.stop, b.stop)
return slice(_in, _out)
if isinstance(a, slice):
if not isinstance(b, slice):
b = b[0]
return slice_intersect(a, b)
b = (b,) if isinstance(b, slice) else b
return tuple(slice_intersect(sa, sb) for sa, sb in zip(a, b))
def roi_center(roi):
""" Return center point of roi
"""
def slice_center(s):
return (s.start + s.stop)*0.5
if isinstance(roi, slice):
return slice_center(roi)
return tuple(slice_center(s) for s in roi)
def roi_from_points(xy, shape, padding=0, align=None):
"""
Compute envelope around a bunch of points and return it as roi (tuple of
row/col slices)
Returned roi is clipped (0,0) --> shape, so it won't stick outside of the
valid region.
"""
def to_roi(*args):
return tuple(slice(v[0], v[1]) for v in args)
assert len(shape) == 2
assert xy.ndim == 2 and xy.shape[1] == 2
ny, nx = shape
_in = np.floor(xy.min(axis=0)).astype('int32') - padding
_out = np.ceil(xy.max(axis=0)).astype('int32') + padding
if align is not None:
_in = align_down(_in, align)
_out = align_up(_out, align)
xx = np.asarray([_in[0], _out[0]])
yy = np.asarray([_in[1], _out[1]])
xx = np.clip(xx, 0, nx, out=xx)
yy = np.clip(yy, 0, ny, out=yy)
return to_roi(yy, xx)
def compute_reproject_roi(src, dst, padding=None, align=None):
"""Given two GeoBoxes find the region within the source GeoBox that overlaps
with the destination GeoBox, and also compute the scale factor (>1 means
shrink). Scale is chosen such that if you apply it to the source image
before reprojecting, then reproject will have roughly no scale component.
So we breaking up reprojection into two stages:
1. Scale in the native pixel CRS
2. Reprojection (possibly non-linear with CRS change)
- src[roi] -> scale -> reproject -> dst (using native pixels)
- src(scale)[roi(scale)] -> reproject -> dst (using overview image)
Here roi is "minimal", padding is configurable though, so you only read what you need.
Also scale can be used to pick the right kind of overview level to read.
Applying reprojection in two steps allows us to use pre-computed overviews,
particularly useful when shrink factor is large. But even for data sources
without overviews there are advantages for shrinking source image before
applying reprojection: mainly quality of the output (reduces aliasing for
large shrink factors), improved efficiency of the computation is likely as
well.
Also compute and return ROI of the dst geobox that is affected by src.
If padding is None "appropriate" padding will be used depending on the
transform between src<>dst:
- No padding beyond sub-pixel alignment if Scale+Translation
- 1 pixel source padding in all other cases
:returns: SimpleNamespace with following fields:
.roi_src : (slice, slice)
.roi_dst : (slice, slice)
.scale : float
.scale2 : (sx: float, sy: float)
.is_st : True|False
.transform : src coord -> dst coord
For scale direction is: "scale > 1 --> shrink src to fit dst"
"""
pts_per_side = 5
def compute_roi(src, dst, tr, pts_per_side, padding, align):
XY = np.vstack(tr.back(gbox_boundary(dst, pts_per_side)))
roi_src = roi_from_points(XY, src.shape, padding, align=align)
# project src roi back into dst and compute roi from that
xy = np.vstack(tr(roi_boundary(roi_src, pts_per_side)))
roi_dst = roi_from_points(xy, dst.shape, padding=0) # no need to add padding twice
return (roi_src, roi_dst)
tr = native_pix_transform(src, dst)
if tr.linear is not None:
tight_ok = align in (None, 0) and padding in (0, None)
is_st = is_affine_st(tr.linear)
if tight_ok and is_st:
roi_src, roi_dst = box_overlap(src.shape, dst.shape, tr.back.linear)
else:
padding = 1 if padding is None else padding
roi_src, roi_dst = compute_roi(src, dst, tr, 2, padding, align)
scale2 = get_scale_from_linear_transform(tr.linear)
else:
is_st = False
padding = 1 if padding is None else padding
roi_src, roi_dst = compute_roi(src, dst, tr, pts_per_side, padding, align)
center_pt = roi_center(roi_src)[::-1]
scale2 = get_scale_at_point(center_pt, tr)
# change scale direction to be a shrink by factor
scale2 = tuple(1/s for s in scale2)
scale = min(scale2)
return SimpleNamespace(roi_src=roi_src,
roi_dst=roi_dst,
scale=scale,
scale2=scale2,
is_st=is_st,
transform=tr)
|
"""
Django settings for polyclinic project.
Generated by 'django-admin startproject' using Django 1.8.4.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.8/ref/settings/
"""
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'srhq*(rwy3z)l+uf5ivaq_)nrq*^#wl$-#fu9j=+zs6eivm5fz'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'appointments',
'bootstrap3',
'datetimewidget',
)
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.middleware.security.SecurityMiddleware',
)
ROOT_URLCONF = 'polyclinic.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'polyclinic.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Internationalization
# https://docs.djangoproject.com/en/1.8/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'Europe/Moscow'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.8/howto/static-files/
BOOTSTRAP3 = {
'jquery_url': '//code.jquery.com/jquery.min.js',
}
STATIC_URL = '/static/'
|
sap.ui.define(["sap/ui/core/UIComponent", "sap/ui/core/ComponentSupport"], function(UIComponent) {
"use strict";
return UIComponent.extend("els.org.pratideen.Component", {
metadata: {
manifest: "json"
},
init: function() {
debugger;
// call the base component's init function and create the App view
UIComponent.prototype.init.apply(this, arguments);
// create the views based on the url/hash
this.getRouter().initialize();
// var oRouter = UIComponent.getRouterFor(this);
// oRouter.initialize();
},
destroy: function() {
// call the base component's destroy function
UIComponent.prototype.destroy.apply(this, arguments);
},
getContentDensityClass: function() {
if (this._sContentDensityClass === undefined) {
// check whether FLP has already set the content density class; do nothing in this case
if (jQuery(document.body).hasClass("sapUiSizeCozy") || jQuery(document.body).hasClass("sapUiSizeCompact")) {
this._sContentDensityClass = "";
} else if (!Device.support.touch) { // apply "compact" mode if touch is not supported
this._sContentDensityClass = "sapUiSizeCompact";
} else {
// "cozy" in case of touch support; default for most sap.m controls, but needed for desktop-first controls like sap.ui.table.Table
this._sContentDensityClass = "sapUiSizeCozy";
}
}
return this._sContentDensityClass;
}
});
});
|
"""
check for common build errors
"""
import json
import os
import sys
_this_dir = os.path.dirname(__file__)
_parent = os.path.realpath(os.path.join(_this_dir, '..'))
def check_messages():
_messages = os.path.realpath(os.path.join(_parent, 'messages.json'))
_messages_dir = os.path.realpath(os.path.join(_parent, 'messages'))
msg_paths = None
try:
with open(_messages, 'r') as f:
msg_paths = json.load(f)
except Exception as e:
print('syntax error in messages.json')
print('=' * 80)
print(e)
print('=' * 80)
sys.exit(1)
def exists(path):
if os.path.exists(os.path.join(_parent, path)):
return True
def is_name_correct(key, path):
name = os.path.basename(path)
return (key == os.path.splitext(name)[0])
# is there a file for each message?
for (key, rel_path) in msg_paths.items():
if not is_name_correct(key, rel_path):
print('file name not correct: {0} ==> {1}'.format(key, rel_path))
sys.exit(1)
if not exists(rel_path):
print('message file not found: {0}'.format(rel_path))
sys.exit(1)
if __name__ == '__main__':
check_messages()
|
/*
Copyright (c) 2003-2015, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.lang['nb']={"undo":{"redo":"Gjør om","undo":"Angre"},"toolbar":{"toolbarCollapse":"Skjul verktøylinje","toolbarExpand":"Vis verktøylinje","toolbarGroups":{"document":"Dokument","clipboard":"Utklippstavle/Angre","editing":"Redigering","forms":"Skjema","basicstyles":"Basisstiler","paragraph":"Avsnitt","links":"Lenker","insert":"Innsetting","styles":"Stiler","colors":"Farger","tools":"Verktøy"},"toolbars":"Verktøylinjer for editor"},"templates":{"button":"Maler","emptyListMsg":"(Ingen maler definert)","insertOption":"Erstatt gjeldende innhold","options":"Alternativer for mal","selectPromptMsg":"Velg malen du vil åpne i redigeringsverktøyet:","title":"Innholdsmaler"},"table":{"border":"Rammestørrelse","caption":"Tittel","cell":{"menu":"Celle","insertBefore":"Sett inn celle før","insertAfter":"Sett inn celle etter","deleteCell":"Slett celler","merge":"Slå sammen celler","mergeRight":"Slå sammen høyre","mergeDown":"Slå sammen ned","splitHorizontal":"Del celle horisontalt","splitVertical":"Del celle vertikalt","title":"Celleegenskaper","cellType":"Celletype","rowSpan":"Radspenn","colSpan":"Kolonnespenn","wordWrap":"Tekstbrytning","hAlign":"Horisontal justering","vAlign":"Vertikal justering","alignBaseline":"Grunnlinje","bgColor":"Bakgrunnsfarge","borderColor":"Rammefarge","data":"Data","header":"Overskrift","yes":"Ja","no":"Nei","invalidWidth":"Cellebredde må være et tall.","invalidHeight":"Cellehøyde må være et tall.","invalidRowSpan":"Radspenn må være et heltall.","invalidColSpan":"Kolonnespenn må være et heltall.","chooseColor":"Velg"},"cellPad":"Cellepolstring","cellSpace":"Cellemarg","column":{"menu":"Kolonne","insertBefore":"Sett inn kolonne før","insertAfter":"Sett inn kolonne etter","deleteColumn":"Slett kolonner"},"columns":"Kolonner","deleteTable":"Slett tabell","headers":"Overskrifter","headersBoth":"Begge","headersColumn":"Første kolonne","headersNone":"Ingen","headersRow":"Første rad","invalidBorder":"Rammestørrelse må være et tall.","invalidCellPadding":"Cellepolstring må være et positivt tall.","invalidCellSpacing":"Cellemarg må være et positivt tall.","invalidCols":"Antall kolonner må være et tall større enn 0.","invalidHeight":"Tabellhøyde må være et tall.","invalidRows":"Antall rader må være et tall større enn 0.","invalidWidth":"Tabellbredde må være et tall.","menu":"Egenskaper for tabell","row":{"menu":"Rader","insertBefore":"Sett inn rad før","insertAfter":"Sett inn rad etter","deleteRow":"Slett rader"},"rows":"Rader","summary":"Sammendrag","title":"Egenskaper for tabell","toolbar":"Tabell","widthPc":"prosent","widthPx":"piksler","widthUnit":"Bredde-enhet"},"stylescombo":{"label":"Stil","panelTitle":"Stilformater","panelTitle1":"Blokkstiler","panelTitle2":"Inlinestiler","panelTitle3":"Objektstiler"},"specialchar":{"options":"Alternativer for spesialtegn","title":"Velg spesialtegn","toolbar":"Sett inn spesialtegn"},"sourcearea":{"toolbar":"Kilde"},"smiley":{"options":"Alternativer for smil","title":"Sett inn smil","toolbar":"Smil"},"showblocks":{"toolbar":"Vis blokker"},"selectall":{"toolbar":"Merk alt"},"save":{"toolbar":"Lagre"},"removeformat":{"toolbar":"Fjern formatering"},"preview":{"preview":"Forhåndsvis"},"pastetext":{"button":"Lim inn som ren tekst","title":"Lim inn som ren tekst"},"pastefromword":{"confirmCleanup":"Teksten du limer inn ser ut til å være kopiert fra Word. Vil du renske den før du limer den inn?","error":"Det var ikke mulig å renske den innlimte teksten på grunn av en intern feil","title":"Lim inn fra Word","toolbar":"Lim inn fra Word"},"pagebreak":{"alt":"Sideskift","toolbar":"Sett inn sideskift for utskrift"},"newpage":{"toolbar":"Ny side"},"maximize":{"maximize":"Maksimer","minimize":"Minimer"},"magicline":{"title":"Sett inn nytt avsnitt her"},"liststyle":{"armenian":"Armensk nummerering","bulletedTitle":"Egenskaper for punktmerket liste","circle":"Sirkel","decimal":"Tall (1, 2, 3, osv.)","decimalLeadingZero":"Tall, med førstesiffer null (01, 02, 03, osv.)","disc":"Disk","georgian":"Georgisk nummerering (an, ban, gan, osv.)","lowerAlpha":"Alfabetisk, små (a, b, c, d, e, osv.)","lowerGreek":"Gresk, små (alpha, beta, gamma, osv.)","lowerRoman":"Romertall, små (i, ii, iii, iv, v, osv.)","none":"Ingen","notset":"<ikke satt>","numberedTitle":"Egenskaper for nummerert liste","square":"Firkant","start":"Start","type":"Type","upperAlpha":"Alfabetisk, store (A, B, C, D, E, osv.)","upperRoman":"Romertall, store (I, II, III, IV, V, osv.)","validateStartNumber":"Starten på listen må være et heltall."},"list":{"bulletedlist":"Legg til / fjern punktmerket liste","numberedlist":"Legg til / fjern nummerert liste"},"link":{"acccessKey":"Aksessknapp","advanced":"Avansert","advisoryContentType":"Type","advisoryTitle":"Tittel","anchor":{"toolbar":"Sett inn/Rediger anker","menu":"Egenskaper for anker","title":"Egenskaper for anker","name":"Ankernavn","errorName":"Vennligst skriv inn ankernavnet","remove":"Fjern anker"},"anchorId":"Element etter ID","anchorName":"Anker etter navn","charset":"Lenket tegnsett","cssClasses":"Stilarkklasser","emailAddress":"E-postadresse","emailBody":"Melding","emailSubject":"Meldingsemne","id":"Id","info":"Lenkeinfo","langCode":"Språkkode","langDir":"Språkretning","langDirLTR":"Venstre til høyre (VTH)","langDirRTL":"Høyre til venstre (HTV)","menu":"Rediger lenke","name":"Navn","noAnchors":"(Ingen anker i dokumentet)","noEmail":"Vennligst skriv inn e-postadressen","noUrl":"Vennligst skriv inn lenkens URL","other":"<annen>","popupDependent":"Avhenging (Netscape)","popupFeatures":"Egenskaper for popup-vindu","popupFullScreen":"Fullskjerm (IE)","popupLeft":"Venstre posisjon","popupLocationBar":"Adresselinje","popupMenuBar":"Menylinje","popupResizable":"Skalerbar","popupScrollBars":"Scrollbar","popupStatusBar":"Statuslinje","popupToolbar":"Verktøylinje","popupTop":"Topp-posisjon","rel":"Relasjon (rel)","selectAnchor":"Velg et anker","styles":"Stil","tabIndex":"Tabindeks","target":"Mål","targetFrame":"<ramme>","targetFrameName":"Målramme","targetPopup":"<popup-vindu>","targetPopupName":"Navn på popup-vindu","title":"Lenke","toAnchor":"Lenke til anker i teksten","toEmail":"E-post","toUrl":"URL","toolbar":"Sett inn/Rediger lenke","type":"Lenketype","unlink":"Fjern lenke","upload":"Last opp"},"justify":{"block":"Blokkjuster","center":"Midtstill","left":"Venstrejuster","right":"Høyrejuster"},"indent":{"indent":"Øk innrykk","outdent":"Reduser innrykk"},"image":{"alt":"Alternativ tekst","border":"Ramme","btnUpload":"Send det til serveren","button2Img":"Vil du endre den valgte bildeknappen til et vanlig bilde?","hSpace":"HMarg","img2Button":"Vil du endre det valgte bildet til en bildeknapp?","infoTab":"Bildeinformasjon","linkTab":"Lenke","lockRatio":"Lås forhold","menu":"Bildeegenskaper","resetSize":"Tilbakestill størrelse","title":"Bildeegenskaper","titleButton":"Egenskaper for bildeknapp","upload":"Last opp","urlMissing":"Bildets adresse mangler.","vSpace":"VMarg","validateBorder":"Ramme må være et heltall.","validateHSpace":"HMarg må være et heltall.","validateVSpace":"VMarg må være et heltall."},"iframe":{"border":"Vis ramme rundt iframe","noUrl":"Vennligst skriv inn URL for iframe","scrolling":"Aktiver scrollefelt","title":"Egenskaper for IFrame","toolbar":"IFrame"},"horizontalrule":{"toolbar":"Sett inn horisontal linje"},"forms":{"button":{"title":"Egenskaper for knapp","text":"Tekst (verdi)","type":"Type","typeBtn":"Knapp","typeSbm":"Send","typeRst":"Nullstill"},"checkboxAndRadio":{"checkboxTitle":"Egenskaper for avmerkingsboks","radioTitle":"Egenskaper for alternativknapp","value":"Verdi","selected":"Valgt","required":"Påkrevd"},"form":{"title":"Egenskaper for skjema","menu":"Egenskaper for skjema","action":"Handling","method":"Metode","encoding":"Encoding"},"hidden":{"title":"Egenskaper for skjult felt","name":"Navn","value":"Verdi"},"select":{"title":"Egenskaper for rullegardinliste","selectInfo":"Info","opAvail":"Tilgjenglige alternativer","value":"Verdi","size":"Størrelse","lines":"Linjer","chkMulti":"Tillat flervalg","required":"Påkrevd","opText":"Tekst","opValue":"Verdi","btnAdd":"Legg til","btnModify":"Endre","btnUp":"Opp","btnDown":"Ned","btnSetValue":"Sett som valgt","btnDelete":"Slett"},"textarea":{"title":"Egenskaper for tekstområde","cols":"Kolonner","rows":"Rader"},"textfield":{"title":"Egenskaper for tekstfelt","name":"Navn","value":"Verdi","charWidth":"Tegnbredde","maxChars":"Maks antall tegn","required":"Påkrevd","type":"Type","typeText":"Tekst","typePass":"Passord","typeEmail":"Epost","typeSearch":"Søk","typeTel":"Telefonnummer","typeUrl":"URL"}},"format":{"label":"Format","panelTitle":"Avsnittsformat","tag_address":"Adresse","tag_div":"Normal (DIV)","tag_h1":"Overskrift 1","tag_h2":"Overskrift 2","tag_h3":"Overskrift 3","tag_h4":"Overskrift 4","tag_h5":"Overskrift 5","tag_h6":"Overskrift 6","tag_p":"Normal","tag_pre":"Formatert"},"font":{"fontSize":{"label":"Størrelse","voiceLabel":"Skriftstørrelse","panelTitle":"Skriftstørrelse"},"label":"Skrift","panelTitle":"Skrift","voiceLabel":"Font"},"flash":{"access":"Scripttilgang","accessAlways":"Alltid","accessNever":"Aldri","accessSameDomain":"Samme domene","alignAbsBottom":"Abs bunn","alignAbsMiddle":"Abs midten","alignBaseline":"Bunnlinje","alignTextTop":"Tekst topp","bgcolor":"Bakgrunnsfarge","chkFull":"Tillat fullskjerm","chkLoop":"Loop","chkMenu":"Slå på Flash-meny","chkPlay":"Autospill","flashvars":"Variabler for flash","hSpace":"HMarg","properties":"Egenskaper for Flash-objekt","propertiesTab":"Egenskaper","quality":"Kvalitet","qualityAutoHigh":"Auto høy","qualityAutoLow":"Auto lav","qualityBest":"Best","qualityHigh":"Høy","qualityLow":"Lav","qualityMedium":"Medium","scale":"Skaler","scaleAll":"Vis alt","scaleFit":"Skaler til å passe","scaleNoBorder":"Ingen ramme","title":"Flash-egenskaper","vSpace":"VMarg","validateHSpace":"HMarg må være et tall.","validateSrc":"Vennligst skriv inn lenkens url.","validateVSpace":"VMarg må være et tall.","windowMode":"Vindumodus","windowModeOpaque":"Opaque","windowModeTransparent":"Gjennomsiktig","windowModeWindow":"Vindu"},"find":{"find":"Søk","findOptions":"Søkealternativer","findWhat":"Søk etter:","matchCase":"Skill mellom store og små bokstaver","matchCyclic":"Søk i hele dokumentet","matchWord":"Bare hele ord","notFoundMsg":"Fant ikke søketeksten.","replace":"Erstatt","replaceAll":"Erstatt alle","replaceSuccessMsg":"%1 tilfelle(r) erstattet.","replaceWith":"Erstatt med:","title":"Søk og erstatt"},"fakeobjects":{"anchor":"Anker","flash":"Flash-animasjon","hiddenfield":"Skjult felt","iframe":"IFrame","unknown":"Ukjent objekt"},"div":{"IdInputLabel":"Id","advisoryTitleInputLabel":"Tittel","cssClassInputLabel":"Stilark-klasser","edit":"Rediger Div","inlineStyleInputLabel":"Inlinestiler","langDirLTRLabel":"Venstre til høyre (VTH)","langDirLabel":"Språkretning","langDirRTLLabel":"Høyre til venstre (HTV)","languageCodeInputLabel":" Språkkode","remove":"Fjern Div","styleSelectLabel":"Stil","title":"Sett inn Div Container","toolbar":"Sett inn Div Container"},"contextmenu":{"options":"Alternativer for høyreklikkmeny"},"colordialog":{"clear":"Tøm","highlight":"Merk","options":"Alternativer for farge","selected":"Valgt farge","title":"Velg farge"},"colorbutton":{"auto":"Automatisk","bgColorTitle":"Bakgrunnsfarge","colors":{"000":"Svart","800000":"Rødbrun","8B4513":"Salbrun","2F4F4F":"Grønnsvart","008080":"Blågrønn","000080":"Marineblått","4B0082":"Indigo","696969":"Mørk grå","B22222":"Mørkerød","A52A2A":"Brun","DAA520":"Lys brun","006400":"Mørk grønn","40E0D0":"Turkis","0000CD":"Medium blå","800080":"Purpur","808080":"Grå","F00":"Rød","FF8C00":"Mørk oransje","FFD700":"Gull","008000":"Grønn","0FF":"Cyan","00F":"Blå","EE82EE":"Fiolett","A9A9A9":"Svak grå","FFA07A":"Rosa-oransje","FFA500":"Oransje","FFFF00":"Gul","00FF00":"Lime","AFEEEE":"Svak turkis","ADD8E6":"Lys Blå","DDA0DD":"Plomme","D3D3D3":"Lys grå","FFF0F5":"Svak lavendelrosa","FAEBD7":"Antikk-hvit","FFFFE0":"Lys gul","F0FFF0":"Honningmelon","F0FFFF":"Svakt asurblått","F0F8FF":"Svak cyan","E6E6FA":"Lavendel","FFF":"Hvit"},"more":"Flere farger...","panelTitle":"Farger","textColorTitle":"Tekstfarge"},"clipboard":{"copy":"Kopier","copyError":"Din nettlesers sikkerhetsinstillinger tillater ikke automatisk kopiering av tekst. Vennligst bruk tastatursnarveien (Ctrl/Cmd+C).","cut":"Klipp ut","cutError":"Din nettlesers sikkerhetsinstillinger tillater ikke automatisk utklipping av tekst. Vennligst bruk tastatursnarveien (Ctrl/Cmd+X).","paste":"Lim inn","pasteArea":"Innlimingsområde","pasteMsg":"Vennligst lim inn i følgende boks med tastaturet (<strong>Ctrl/Cmd+V</strong>) og trykk <strong>OK</strong>.","securityMsg":"Din nettlesers sikkerhetsinstillinger gir ikke redigeringsverktøyet direkte tilgang til utklippstavlen. Du må derfor lime det inn på nytt i dette vinduet.","title":"Lim inn"},"button":{"selectedLabel":"%1 (Valgt)"},"blockquote":{"toolbar":"Blokksitat"},"bidi":{"ltr":"Tekstretning fra venstre til høyre","rtl":"Tekstretning fra høyre til venstre"},"basicstyles":{"bold":"Fet","italic":"Kursiv","strike":"Gjennomstreking","subscript":"Senket skrift","superscript":"Hevet skrift","underline":"Understreking"},"editor":"Rikteksteditor","editorPanel":"Panel for rikteksteditor","common":{"editorHelp":"Trykk ALT 0 for hjelp","browseServer":"Bla gjennom tjener","url":"URL","protocol":"Protokoll","upload":"Last opp","uploadSubmit":"Send det til serveren","image":"Bilde","flash":"Flash","form":"Skjema","checkbox":"Avmerkingsboks","radio":"Alternativknapp","textField":"Tekstboks","textarea":"Tekstområde","hiddenField":"Skjult felt","button":"Knapp","select":"Rullegardinliste","imageButton":"Bildeknapp","notSet":"<ikke satt>","id":"Id","name":"Navn","langDir":"Språkretning","langDirLtr":"Venstre til høyre (VTH)","langDirRtl":"Høyre til venstre (HTV)","langCode":"Språkkode","longDescr":"Utvidet beskrivelse","cssClass":"Stilarkklasser","advisoryTitle":"Tittel","cssStyle":"Stil","ok":"OK","cancel":"Avbryt","close":"Lukk","preview":"Forhåndsvis","resize":"Dra for å skalere","generalTab":"Generelt","advancedTab":"Avansert","validateNumberFailed":"Denne verdien er ikke et tall.","confirmNewPage":"Alle ulagrede endringer som er gjort i dette innholdet vil gå tapt. Er du sikker på at du vil laste en ny side?","confirmCancel":"Du har endret noen alternativer. Er du sikker på at du vil lukke dialogvinduet?","options":"Valg","target":"Mål","targetNew":"Nytt vindu (_blank)","targetTop":"Hele vindu (_top)","targetSelf":"Samme vindu (_self)","targetParent":"Foreldrevindu (_parent)","langDirLTR":"Venstre til høyre (VTH)","langDirRTL":"Høyre til venstre (HTV)","styles":"Stil","cssClasses":"Stilarkklasser","width":"Bredde","height":"Høyde","align":"Juster","alignLeft":"Venstre","alignRight":"Høyre","alignCenter":"Midtjuster","alignJustify":"Blokkjuster","alignTop":"Topp","alignMiddle":"Midten","alignBottom":"Bunn","alignNone":"Ingen","invalidValue":"Ugyldig verdi.","invalidHeight":"Høyde må være et tall.","invalidWidth":"Bredde må være et tall.","invalidCssLength":"Den angitte verdien for feltet \"%1\" må være et positivt tall med eller uten en gyldig CSS-målingsenhet (px, %, in, cm, mm, em, ex, pt, eller pc).","invalidHtmlLength":"Den angitte verdien for feltet \"%1\" må være et positivt tall med eller uten en gyldig HTML-målingsenhet (px eller %).","invalidInlineStyle":"Verdi angitt for inline stil må bestå av en eller flere sett med formatet \"navn : verdi\", separert med semikolon","cssLengthTooltip":"Skriv inn et tall for en piksel-verdi eller et tall med en gyldig CSS-enhet (px, %, in, cm, mm, em, ex, pt, eller pc).","unavailable":"%1<span class=\"cke_accessibility\">, utilgjenglig</span>"}}; |
(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-97846336"],{"166a":function(t,e,i){},"2f71":function(t,e,i){},"32b1":function(t,e,i){"use strict";var s=i("f0ff"),o=i.n(s);o.a},3408:function(t,e,i){},"3ad0":function(t,e,i){},"5d41":function(t,e,i){var s=i("23e7"),o=i("861d"),n=i("825a"),a=i("5135"),l=i("06cf"),r=i("e163");function c(t,e){var i,s,u=arguments.length<3?t:arguments[2];return n(t)===u?t[e]:(i=l.f(t,e))?a(i,"value")?i.value:void 0===i.get?void 0:i.get.call(u):o(s=r(t))?c(s,e,u):void 0}s({target:"Reflect",stat:!0},{get:c})},"604c":function(t,e,i){"use strict";i.d(e,"a",(function(){return r}));i("4de4"),i("7db0"),i("c740"),i("4160"),i("caad"),i("c975"),i("fb6a"),i("a434"),i("a9e3"),i("2532"),i("159b");var s=i("5530"),o=(i("166a"),i("a452")),n=i("7560"),a=i("58df"),l=i("d9bd"),r=Object(a["a"])(o["a"],n["a"]).extend({name:"base-item-group",props:{activeClass:{type:String,default:"v-item--active"},mandatory:Boolean,max:{type:[Number,String],default:null},multiple:Boolean},data:function(){return{internalLazyValue:void 0!==this.value?this.value:this.multiple?[]:void 0,items:[]}},computed:{classes:function(){return Object(s["a"])({"v-item-group":!0},this.themeClasses)},selectedIndex:function(){return this.selectedItem&&this.items.indexOf(this.selectedItem)||-1},selectedItem:function(){if(!this.multiple)return this.selectedItems[0]},selectedItems:function(){var t=this;return this.items.filter((function(e,i){return t.toggleMethod(t.getValue(e,i))}))},selectedValues:function(){return null==this.internalValue?[]:Array.isArray(this.internalValue)?this.internalValue:[this.internalValue]},toggleMethod:function(){var t=this;if(!this.multiple)return function(e){return t.internalValue===e};var e=this.internalValue;return Array.isArray(e)?function(t){return e.includes(t)}:function(){return!1}}},watch:{internalValue:"updateItemsState",items:"updateItemsState"},created:function(){this.multiple&&!Array.isArray(this.internalValue)&&Object(l["c"])("Model must be bound to an array if the multiple property is true.",this)},methods:{genData:function(){return{class:this.classes}},getValue:function(t,e){return null==t.value||""===t.value?e:t.value},onClick:function(t){this.updateInternalValue(this.getValue(t,this.items.indexOf(t)))},register:function(t){var e=this,i=this.items.push(t)-1;t.$on("change",(function(){return e.onClick(t)})),this.mandatory&&!this.selectedValues.length&&this.updateMandatory(),this.updateItem(t,i)},unregister:function(t){if(!this._isDestroyed){var e=this.items.indexOf(t),i=this.getValue(t,e);this.items.splice(e,1);var s=this.selectedValues.indexOf(i);if(!(s<0)){if(!this.mandatory)return this.updateInternalValue(i);this.multiple&&Array.isArray(this.internalValue)?this.internalValue=this.internalValue.filter((function(t){return t!==i})):this.internalValue=void 0,this.selectedItems.length||this.updateMandatory(!0)}}},updateItem:function(t,e){var i=this.getValue(t,e);t.isActive=this.toggleMethod(i)},updateItemsState:function(){var t=this;this.$nextTick((function(){if(t.mandatory&&!t.selectedItems.length)return t.updateMandatory();t.items.forEach(t.updateItem)}))},updateInternalValue:function(t){this.multiple?this.updateMultiple(t):this.updateSingle(t)},updateMandatory:function(t){if(this.items.length){var e=this.items.slice();t&&e.reverse();var i=e.find((function(t){return!t.disabled}));if(i){var s=this.items.indexOf(i);this.updateInternalValue(this.getValue(i,s))}}},updateMultiple:function(t){var e=Array.isArray(this.internalValue)?this.internalValue:[],i=e.slice(),s=i.findIndex((function(e){return e===t}));this.mandatory&&s>-1&&i.length-1<1||null!=this.max&&s<0&&i.length+1>this.max||(s>-1?i.splice(s,1):i.push(t),this.internalValue=i)},updateSingle:function(t){var e=t===this.internalValue;this.mandatory&&e||(this.internalValue=e?void 0:t)}},render:function(t){return t("div",this.genData(),this.$slots.default)}});r.extend({name:"v-item-group",provide:function(){return{itemGroup:this}}})},"60d8":function(t,e,i){"use strict";var s=i("a9cc"),o=i.n(s);o.a},"61d2":function(t,e,i){},"899c":function(t,e,i){},a9cc:function(t,e,i){},b853:function(t,e,i){"use strict";var s=i("2f71"),o=i.n(s);o.a},db42:function(t,e,i){},e49f:function(t,e,i){"use strict";i.r(e);var s=function(){var t=this,e=t.$createElement,i=t._self._c||e;return i("div",{staticClass:"mb-4 row col-padding-0 release_thread"},[i("node_list_dialog",{attrs:{show_types:t.show_types,dialog_title:"请选择板块",show:t.show_node_dialog},on:{"update:show":function(e){t.show_node_dialog=e},on_select_forum:t.on_dialog_select_forum}}),t.editor?t._e():i("div",{staticClass:"col-9"},[i("div",{staticClass:"card pa-3"},[i("q-card-section",{staticClass:"p-0 mb-4"},[i("q-skeleton",{attrs:{height:"40px"}})],1),i("q-card-section",{staticClass:"p-0 mb-4"},[i("q-skeleton",{attrs:{height:"60px"}})],1),i("q-card-section",{staticClass:"p-0"},[i("q-skeleton",{attrs:{height:"450px"}})],1)],1)]),t.post_success?i("div",{staticClass:"col-9 pr-2 mpr-0",staticStyle:{"margin-bottom":"16px"}},[i("div",{staticClass:"card"},[i("div",{staticClass:"card-header"},[t._v("提示")]),i("div",{staticClass:"card-body"},[i("span",{staticClass:"mr-4"},[t._v(" "+t._s(t.post_success_tip))]),i("v-btn",{attrs:{color:"white darken-1",text:""},on:{click:function(e){t.post_success=!1}}},[t._v("继续编辑")]),i("div",{staticClass:"mt-3"},[i("v-btn",{attrs:{color:"white darken-1",text:""},on:{click:function(e){return t.go("/topic/"+t.edit_id+"?edit=true")}}},[t._v("查看(可能未更新) ")])],1)],1)])]):t._e(),i("div",{directives:[{name:"show",rawName:"v-show",value:t.editor&&!t.post_success,expression:"editor && !post_success"}],staticClass:"col-9 pr-2 mpr-0"},[i("div",{staticClass:"card card-lg pa-3"},[i("h1",{staticClass:"b__title mb-5"},[t._v(" 发布 ")]),i("form",{on:{submit:function(e){return e.preventDefault(),e.stopPropagation(),t.onSubmit(e)},reset:function(e){return e.preventDefault(),e.stopPropagation(),t.onReset(e)}}},[i("div",{staticClass:"mb-3"},[i("span",[t._v(" "+t._s(t.$l("thread.node"))+": ")]),i("span",{staticClass:"select_node font-weight-bold",on:{click:t.on_select_node}},[t._v(" 请选择板块 "),i("v-icon",{attrs:{color:"grey",small:!0,dark:""}},[t._v(" far fa-hand-pointer ")])],1),t.this_forum_conf.name?i("span",{staticClass:"ml-2 font-weight-bold"},[t._v(" / "+t._s(t.this_forum_conf.name))]):t._e(),i("node_list_dialog",{attrs:{cl:""},on:{on_select_forum:t.on_dialog_select_forum}}),i("q-btn",{staticClass:"padding_none none",attrs:{unelevated:"",color:"black",label:t.show_select_forum_text?t.show_select_forum_text:"请选择"}},[i("q-menu",[i("q-list",{staticStyle:{"min-width":"100px"},attrs:{dense:""}},[t._l(t.forums_options,(function(e){return i("q-item",{key:e.fid,attrs:{clickable:""},on:{click:function(i){return t.on_select_forum(e)}}},[i("q-item-section",[t._v(t._s(e.name))]),i("q-item-section",{attrs:{side:""}},[i("q-icon",{attrs:{name:"keyboard_arrow_right"}})],1),i("q-menu",{attrs:{anchor:"top right",self:"top left"}},[i("q-list",t._l(e.list,(function(e){return i("q-item",{directives:[{name:"close-popup",rawName:"v-close-popup"}],key:e.fid,attrs:{dense:"",clickable:""},on:{click:function(i){return t.on_select_forum(e)}}},[i("q-item-section",[t._v(t._s(e.name))])],1)})),1)],1)],1)})),i("q-separator")],2)],1)],1)],1),i("q-input",{staticClass:"mb-3",attrs:{label:"标题"},model:{value:t.thread.title,callback:function(e){t.$set(t.thread,"title",e)},expression:"thread.title"}}),i("div",{staticClass:"card-body markdown-toc entry-content markdown ql-container ql-snow",attrs:{id:"editor"}}),t.editor_setting.release&&t.editor_setting.release.buy?i("v-row",{staticClass:"mt-5",staticStyle:{"margin-left":"0px","margin-right":"0px"}},[t.editor_setting.release.buy_content?i("q-btn",{staticClass:"mr-5",attrs:{unelevated:"",color:"primary",icon:"far fa-plus-square",label:t.$l("thread.attach_content")},on:{click:function(e){return t.on_show_attach_content_dialog(void 0)}}}):t._e(),!1&t.editor_setting.release.buy_theav?i("q-btn",{attrs:{unelevated:"",size:"sm",color:"primary",icon:"far fa-plus-square",label:t.add_buy_theav_open?"移除付费影片":"添加付费影片"},on:{click:t.add_buy_theav}}):t._e()],1):t._e(),t.buy_contents&&t.buy_contents.length>0?i("div",{staticClass:"mt-5 card buy_contents"},[i("h6",[t._v(t._s(t.$l("thread.attach_content"))+":")]),t._l(t.buy_contents,(function(e,s){return i("v-row",{key:s},[i("v-col",[t._v(" * "),e.gold?i("span",[t._v("价格:"),i("span",{staticClass:"text-theme-color"},[t._v(t._s(e.gold)+"金币")])]):t._e(),i("span",{staticClass:"ml-2"},[t._v(t._s(e.content))]),e.upload_files&&e.upload_files.length>0?i("span",{staticClass:"ml-2 text-theme-color"},[t._v(" "+t._s(e.upload_files.length)+"个文件 ")]):t._e(),i("span",[i("v-btn",{staticClass:"ma-2",attrs:{tile:"",outlined:"",color:"success"},on:{click:function(i){return t.on_show_attach_content_dialog(e)}}},[i("v-icon",{attrs:{left:""}},[t._v("mdi-pencil")]),t._v(" 编辑 ")],1)],1)])],1)}))],2):t._e(),t.add_buy_theav_open&&t.this_forum_conf.release&&t.this_forum_conf.release.buy?i("div",{staticClass:"mt-5 bbt-module"},[i("h6",[t._v("付费影片:")]),i("v-row",{staticClass:"item buy_price",attrs:{cols:"12"}},[t._v(" 购买价格: "),i("q-input",{staticClass:"col-3",attrs:{outlined:"",placeholder:"0-2000金币",label:"金币"},model:{value:t.buy_theav.price,callback:function(e){t.$set(t.buy_theav,"price",e)},expression:"buy_theav.price"}}),i("q-input",{attrs:{outlined:"",label:"请输入影片ID"},model:{value:t.buy_theav.id,callback:function(e){t.$set(t.buy_theav,"id",e)},expression:"buy_theav.id"}})],1)],1):t._e(),t.editor_setting.release&&t.editor_setting.release.video?i("div",{staticClass:"mt-5"},[t.show_attach_content_dialog?i("attach_content",{attrs:{buy_content:t.buy_content,show:t.show_attach_content_dialog},on:{"update:buy_content":function(e){t.buy_content=e},on_submit:t.on_submit_buy_content,"update:show":function(e){t.show_attach_content_dialog=e}}}):t._e()],1):t._e(),t.thread.setting?i("div",{staticClass:"setting card q-gutter-sm mt-3"},[i("h1",{staticClass:"b__title forum_title"},[t._v(" 设置 ")]),i("q-checkbox",{attrs:{label:"不可回复",color:"primary"},model:{value:t.thread.setting.not_reply,callback:function(e){t.$set(t.thread.setting,"not_reply",e)},expression:"thread.setting.not_reply"}})],1):t._e(),i("div",{staticClass:"submit xxbtn mt-3 cl"},[i("q-btn",{staticClass:"float-right",attrs:{padding:"0px",color:"theme-color",loading:t.release_loading,icon:"far fa-edit","text-color":"theme-color",label:"发布"},on:{click:t.on_release}})],1)],1)])]),i("div",{staticClass:"col-3"},[i("h6",[t._v("注册事项")]),i("div",[t._v(" * 严禁儿童色情和兽交，一禁发现，立即删除并封号。 ")]),i("div",[t._v(" * 违反台湾，美国和荷兰法律的内容，不允许发布 ")]),i("ads_box_list",{staticClass:"mt-4"})],1),i("remote-script",{attrs:{src:"https://"+t.$web_conf.set_host+"/static/quill/quill.js"}}),i("remote-script",{attrs:{src:"https://"+t.$web_conf.set_host+"/static/quill/quill.htmlEditButton.min.js?11"}}),t.loaded_quill?i("remote-script",{attrs:{src:"https://"+t.$web_conf.set_host+"/static/js/editor/image-resize.min.js"}}):t._e(),i("remote-script",{attrs:{src:"https://"+t.$web_conf.set_host+"/static/js/lib/resumable.min.js"}})],1)},o=[],n=(i("c975"),i("b0c0"),i("e439"),i("5d41"),i("7e84"));function a(t,e){while(!Object.prototype.hasOwnProperty.call(t,e))if(t=Object(n["a"])(t),null===t)break;return t}function l(t,e,i){return l="undefined"!==typeof Reflect&&Reflect.get?Reflect.get:function(t,e,i){var s=a(t,e);if(s){var o=Object.getOwnPropertyDescriptor(s,e);return o.get?o.get.call(i):o.value}},l(t,e,i||t)}var r=i("d4ec"),c=i("bee2"),u=i("262e"),d=i("2caf"),h=(i("7bc9"),i("b48a"),i("077f")),_=function(){var t=this,e=t.$createElement,i=t._self._c||e;return i("q-dialog",{staticClass:"xx_dialog",attrs:{persistent:""},model:{value:t.show,callback:function(e){t.show=e},expression:"show"}},[i("q-card",{staticStyle:{"min-width":"40%"}},[i("q-card-section",{staticClass:"row items-center q-pb-none "},[i("div",{staticClass:"text-h6 title "},[t._v(t._s(t.$l("thread.attach_content")))]),i("q-space"),i("q-btn",{directives:[{name:"close-popup",rawName:"v-close-popup"}],attrs:{icon:"close",flat:"",round:"",dense:""}})],1),i("q-card-section",[i("v-row",{staticClass:"item mb-3 buy_price none",attrs:{cols:"1"}},[i("span",{staticClass:"mr-3"},[t._v("购买价格:")]),i("q-input",{staticClass:"col-3",attrs:{type:"number",outlined:"",placeholder:"0-2000金币",label:"金币"},model:{value:t.buy_content.price,callback:function(e){t.$set(t.buy_content,"price",e)},expression:"buy_content.price"}})],1),i("v-row",[i("q-input",{attrs:{outlined:"",label:"请输入文件或者视频的描述"},model:{value:t.buy_content.content,callback:function(e){t.$set(t.buy_content,"content",e)},expression:"buy_content.content"}})],1),i("v-row",{staticClass:"mt-3"},[i("v-btn",{attrs:{color:"white darken-1 ml-4 mr-4",text:""},on:{click:t.on_show_upload_file_dialog}},[i("v-icon",[t._v("add")]),t._v(" "+t._s(t.$l("thread.upload_file"))+" ")],1)],1),this.buy_content.upload_files.length>0?i("div",{staticClass:"mb-3 mt-2"},[i("h5",{staticClass:"text-h6 title"},[t._v("文件列表")]),i("div",[i("v-list-item-group",{attrs:{color:"primary"},model:{value:t.item,callback:function(e){t.item=e},expression:"item"}},t._l(t.buy_content.upload_files,(function(e,s){return i("v-list-item",{key:s},[i("v-list-item-content",[i("v-list-item-title",[t._v(" "+t._s(e.file_name)+" ")]),i("v-list-item-content",[i("q-input",{staticClass:"col-8",attrs:{type:"text",placeholder:"请设置文字显示的名字，不用加后缀名，比如mp4,torrent",label:"请设置文字显示的名字"},model:{value:e.set_name,callback:function(i){t.$set(e,"set_name",i)},expression:"upload_file.set_name"}})],1),i("v-icon",{staticClass:"delete",attrs:{title:t.$l("delete"),dark:""},on:{click:function(i){return t.on_delete_upload_file(e)}}},[t._v("delete ")])],1)],1)})),1)],1)]):t._e(),i("v-row",[i("v-col",[i("q-btn",{staticClass:"float-lg-right",attrs:{color:"primary",label:"确定"},on:{click:t.on_sure}}),i("q-btn",{staticClass:"mr-3 float-lg-right",attrs:{color:"",label:"取消"},on:{click:t.on_close_dialog}})],1)],1),i("v-row",[t.show_upload_file_dialog?i("upload_file",{staticClass:"mt-5",attrs:{show:t.show_upload_file_dialog},on:{upload_complete:t.on_upload_complete,upload_hide:t.on_upload_hide,"update:show":function(e){t.show_upload_file_dialog=e}}}):t._e()],1)],1)],1)],1)},p=[],f=(i("4de4"),function(){var t=this,e=t.$createElement,i=t._self._c||e;return i("q-dialog",{staticClass:"xx_dialog",attrs:{persistent:""},on:{hide:t.on_hide},model:{value:t.show,callback:function(e){t.show=e},expression:"show"}},[i("q-card",[i("q-card-section",{staticClass:"row items-center q-pb-none "},[i("div",{staticClass:"text-h6 title "},[t._v(t._s(t.$l("thread.upload_file")))]),i("q-space"),i("q-btn",{directives:[{name:"close-popup",rawName:"v-close-popup"}],attrs:{icon:"close",flat:"",round:"",dense:""},on:{click:t.on_click_close}})],1),i("q-card-section",[i("v-alert",{directives:[{name:"show",rawName:"v-show",value:!t.uploading_file_name,expression:"!uploading_file_name"}],staticClass:"uploading-tip",attrs:{text:"",color:"red lighten-2"}},[t._v(" 上传的视频文件，请不要打包成压缩包（比如zip,rar）,请上传原始的视频文件。 ")]),t.uploading_file_name?i("v-alert",{staticClass:"uploading-tip",attrs:{text:"",color:"red lighten-2",icon:!1}},[i("span",{staticClass:"title"},[t._v("文件名:")]),t._v(" "),i("span",[t._v(" "+t._s(t.uploading_file_name))])]):t._e(),t.uploading_file_name?i("q-linear-progress",{staticClass:"q-mt-sm mb-3",attrs:{stripe:"",rounded:"",size:"20px",value:t.upload_progress,color:"red"}}):t._e(),t.browse_loading?i("v-alert",{staticClass:"uploading-tip",attrs:{text:"",type:"error",icon:!1}},[i("p",[i("span",[i("span",[t._v("上传进度:")]),t._v(" "+t._s((100*this.upload_progress).toFixed(2))+"% ")])]),i("p",{staticClass:"red"},[t._v(" 正在上传，请不要关闭此窗口 ")])]):t._e(),i("div",{staticClass:"xxbtn"},[i("q-btn",{directives:[{name:"show",rawName:"v-show",value:t.video_upload_resumable,expression:"video_upload_resumable"}],staticClass:"full-width",attrs:{id:"browseButton",icon:"cloud",padding:"0px",color:"theme-color","text-color":"theme-color",loading:t.browse_loading,label:t.browse_button_label}}),t.video_upload_resumable?t._e():i("div",[i("q-skeleton",{attrs:{animation:t.animation,width:"100%",height:"46px"}})],1)],1)],1)],1)],1)}),m=[],v={name:"upload_file",props:{show:void 0},destroyed:function(){this.cancel_upload(),console.log("call destroyed")},created:function(){this.upload_init(),window._upload_file_dialog=this},data:function(){return{call_cancel:!1,orginal_title:document.title,video_upload_resumable:void 0,uploading_file_name:void 0,upload_progress:0,browse_loading:!1,upload_complete:!1,browse_button_label:this.$l("videos.upload"),upload_token:void 0}},watch:{show:function(t,e){this.$emit("update:show",t),console.log("call watch show change")}},methods:{on_click_close:function(t){console.log("on_click_close:",t),this.call_cancel=!0},cancel_upload:function(){this.video_upload_resumable&&(this.video_upload_resumable.cancel(),this.call_cancel=!0,this.set_title(this.orginal_title))},on_hide:function(){console.log("call upload file dialog on hide"),this.cancel_upload(),this.$emit("upload_hide",{})},on_close_dialog:function(){},on_upload_cancel:function(){this.call_cancel=!0},on_upload_error:function(){},on_upload_complete:function(){console.log("this.call_cancel:",this.call_cancel),this.call_cancel||(console.log("call on_upload_complete"),this.upload_complete=!0,this.set_title(this.orginal_title),this.$emit("upload_complete",{file_name:this.uploading_file_name,token:this.upload_token}),this.$q.notify({message:"已成功上传文件。",color:"primary"}),this.show=!1)},on_upload_progress:function(){this.upload_progress=this.video_upload_resumable.progress();var t="("+parseInt(100*this.upload_progress)+"%)正在上传";this.set_title(t),this.browse_loading=!0},on_add_upload_file:function(t,e){console.log("fileAdded:",t,e),this.call_cancel=!1;var i=this.video_upload_resumable.getSize(),s=i/1024/1024;s>10240||(this.video_upload_resumable.upload(),this.uploading_file_name=this.video_upload_resumable.files[0].fileName)},upload_init:function(){var t=this;return window.Resumable?document.getElementById("browseButton")?void this.$axios.get("/app/upload/token").then((function(e){console.log("[upload token]response:",e);var i=e.data.nid,s=t.$config.space_confs[i];console.log("space_conf:",s);var o=s.static_hosts[0],n="https://"+o+"/upload";console.log("upload_target:",n),t.upload_token=e.data.token,t.video_upload_resumable=new window.Resumable({target:n,query:{token:t.upload_token,network:"xx"}}),t.video_upload_resumable.assignBrowse(document.getElementById("browseButton")),t.video_upload_resumable.on("fileAdded",t.on_add_upload_file),t.video_upload_resumable.on("filesAdded",t.on_add_upload_file),t.video_upload_resumable.on("progress",t.on_upload_progress),t.video_upload_resumable.on("error",t.on_upload_error),t.video_upload_resumable.on("complete",t.on_upload_complete)})).catch((function(e){console.log("[upload_file]error:",e),t.show=!1,t.$q.notify({message:"获取上传文件凭证失败，请重试.",color:"primary"}),t.$emit("on_upload_error",{})})):setTimeout(this.upload_init,100):(console.log("no Resumable"),setTimeout(this.upload_init,100))}}},b=v,g=(i("60d8"),i("2877")),y=i("fe09"),w=i("6544"),C=i.n(w),k=i("0798"),x=Object(g["a"])(b,f,m,!1,null,"6ab5020c",null),O=x.exports;x.options.components=Object.assign(Object.create(x.options.components||null),x.options.components||{},{QDialog:y["m"],QCard:y["g"],QCardSection:y["i"],QSpace:y["D"],QBtn:y["e"],QLinearProgress:y["u"],QSkeleton:y["B"]}),x.options.directives=Object.assign(Object.create(x.options.directives||null),x.options.directives||{},{ClosePopup:y["a"]}),C()(x,{VAlert:k["a"]});var $={name:"attach_content",components:{upload_file:O},props:{show:void 0,buy_content:{price:0,content:"",upload_files:[]}},created:function(){console.log("create attach_content:",this.buy_content)},data:function(){return{show_upload_file_dialog:!1}},watch:{show:function(t,e){console.log("call watch show change"),this.$emit("update:show",t)}},methods:{on_sure:function(){if(!this.buy_content.content||this.buy_content.content.length<=1)return this.$q.notify({message:"内空不能为空！",color:"primary"});if(this.buy_content.upload_files&&this.buy_content.upload_files.length>0)for(var t=0;t<this.buy_content.upload_files.length;++t){var e=this.buy_content.upload_files[t];if(!e.set_name)return this.$q.notify({message:"请设置上传文件的显示名称！",color:"primary"})}this.$emit("on_submit",this.buy_content),console.log("[on_sure]:",this.show),this.show=!1,this.$emit("update:show",this.show)},on_close_dialog:function(){var t=this;this.buy_content.upload_files&&this.buy_content.upload_files.length>0?this.$q.dialog({title:"提示",message:"已有文件上传完成，是否确定关闭？",cancel:"取消",persistent:!0,ok:"确定"}).onOk((function(){t.show=!1})).onCancel((function(){})).onDismiss((function(){})):this.show=!1},on_upload_hide:function(){console.log("call on_upload_hide"),this.show_upload_file_dialog=!1},on_upload_complete:function(t){console.log("on_upload_complete:",t);for(var e=0;e<this.buy_content.upload_files.length;++e){var i=this.buy_content.upload_files[e];if(i.token==t.token)return console.log("重复:",t),!1}this.buy_content.upload_files.push(t),this.show_upload_file_dialog=!1},on_delete_upload_file:function(t){var e=this;console.log("on_delete_upload_file:",t),this.$q.dialog({title:"提示",message:"是否确定删除此上传文件？",cancel:"取消",persistent:!0,ok:"确定"}).onOk((function(){e.buy_content.upload_files=e.buy_content.upload_files.filter((function(e){return e.token!=t.token})),console.log("this.buy_content.upload_files:",e.buy_content.upload_files)})).onCancel((function(){})).onDismiss((function(){}))},on_show_upload_file_dialog:function(){var t=this;console.log("call on_show_upload_file_dialog"),this.show_upload_file_dialog=!1,this.$nextTick((function(){t.show_upload_file_dialog=!0})),this.$forceUpdate()}}},j=$,I=(i("32b1"),i("8336")),q=i("62ad"),A=i("132d"),B=i("5530"),V=(i("61d2"),i("a9ad")),S=i("1c87"),L=i("4e82"),Q=i("7560"),N=i("f2e7"),T=i("5607"),M=i("80d2"),R=i("d9bd"),z=i("58df"),E=Object(z["a"])(V["a"],S["a"],Q["a"],Object(L["a"])("listItemGroup"),Object(N["b"])("inputValue")),D=E.extend().extend({name:"v-list-item",directives:{Ripple:T["a"]},inject:{isInGroup:{default:!1},isInList:{default:!1},isInMenu:{default:!1},isInNav:{default:!1}},inheritAttrs:!1,props:{activeClass:{type:String,default:function(){return this.listItemGroup?this.listItemGroup.activeClass:""}},dense:Boolean,inactive:Boolean,link:Boolean,selectable:{type:Boolean},tag:{type:String,default:"div"},threeLine:Boolean,twoLine:Boolean,value:null},data:function(){return{proxyClass:"v-list-item--active"}},computed:{classes:function(){return Object(B["a"])(Object(B["a"])({"v-list-item":!0},S["a"].options.computed.classes.call(this)),{},{"v-list-item--dense":this.dense,"v-list-item--disabled":this.disabled,"v-list-item--link":this.isClickable&&!this.inactive,"v-list-item--selectable":this.selectable,"v-list-item--three-line":this.threeLine,"v-list-item--two-line":this.twoLine},this.themeClasses)},isClickable:function(){return Boolean(S["a"].options.computed.isClickable.call(this)||this.listItemGroup)}},created:function(){this.$attrs.hasOwnProperty("avatar")&&Object(R["d"])("avatar",this)},methods:{click:function(t){t.detail&&this.$el.blur(),this.$emit("click",t),this.to||this.toggle()},genAttrs:function(){var t=Object(B["a"])({"aria-disabled":!!this.disabled||void 0,tabindex:this.isClickable&&!this.disabled?0:-1},this.$attrs);return this.$attrs.hasOwnProperty("role")||this.isInNav||(this.isInGroup?(t.role="listitem",t["aria-selected"]=String(this.isActive)):this.isInMenu?(t.role=this.isClickable?"menuitem":void 0,t.id=t.id||"list-item-".concat(this._uid)):this.isInList&&(t.role="listitem")),t}},render:function(t){var e=this,i=this.generateRouteLink(),s=i.tag,o=i.data;o.attrs=Object(B["a"])(Object(B["a"])({},o.attrs),this.genAttrs()),o[this.to?"nativeOn":"on"]=Object(B["a"])(Object(B["a"])({},o[this.to?"nativeOn":"on"]),{},{keydown:function(t){t.keyCode===M["p"].enter&&e.click(t),e.$emit("keydown",t)}}),this.inactive&&(s="div"),this.inactive&&this.to&&(o.on=o.nativeOn,delete o.nativeOn);var n=this.$scopedSlots.default?this.$scopedSlots.default({active:this.isActive,toggle:this.toggle}):this.$slots.default;return t(s,this.setTextColor(this.color,o),n)}}),G=(i("c740"),i("0481"),i("a434"),i("4069"),i("b85c")),P=(i("3ad0"),i("8dd9")),H=(P["a"].extend().extend({name:"v-list",provide:function(){return{isInList:!0,list:this}},inject:{isInMenu:{default:!1},isInNav:{default:!1}},props:{dense:Boolean,disabled:Boolean,expand:Boolean,flat:Boolean,nav:Boolean,rounded:Boolean,subheader:Boolean,threeLine:Boolean,twoLine:Boolean},data:function(){return{groups:[]}},computed:{classes:function(){return Object(B["a"])(Object(B["a"])({},P["a"].options.computed.classes.call(this)),{},{"v-list--dense":this.dense,"v-list--disabled":this.disabled,"v-list--flat":this.flat,"v-list--nav":this.nav,"v-list--rounded":this.rounded,"v-list--subheader":this.subheader,"v-list--two-line":this.twoLine,"v-list--three-line":this.threeLine})}},methods:{register:function(t){this.groups.push(t)},unregister:function(t){var e=this.groups.findIndex((function(e){return e._uid===t._uid}));e>-1&&this.groups.splice(e,1)},listClick:function(t){if(!this.expand){var e,i=Object(G["a"])(this.groups);try{for(i.s();!(e=i.n()).done;){var s=e.value;s.toggle(t)}}catch(o){i.e(o)}finally{i.f()}}}},render:function(t){var e={staticClass:"v-list",class:this.classes,style:this.styles,attrs:Object(B["a"])({role:this.isInNav||this.isInMenu?void 0:"list"},this.attrs$)};return t(this.tag,this.setBackgroundColor(this.color,e),[this.$slots.default])}}),i("ac1f"),i("466d"),i("ade3")),U=(i("db42"),i("9d26")),J=(i("498a"),i("a026")),F=J["a"].extend({name:"v-list-item-icon",functional:!0,render:function(t,e){var i=e.data,s=e.children;return i.staticClass="v-list-item__icon ".concat(i.staticClass||"").trim(),t("div",i,s)}}),W=i("7e2b"),K=i("9d65"),X=i("3206"),Y=i("0789"),Z=Object(z["a"])(W["a"],K["a"],V["a"],Object(X["a"])("list"),N["a"]),tt=(Z.extend().extend({name:"v-list-group",directives:{ripple:T["a"]},props:{activeClass:{type:String,default:""},appendIcon:{type:String,default:"$expand"},color:{type:String,default:"primary"},disabled:Boolean,group:String,noAction:Boolean,prependIcon:String,ripple:{type:[Boolean,Object],default:!0},subGroup:Boolean},computed:{classes:function(){return{"v-list-group--active":this.isActive,"v-list-group--disabled":this.disabled,"v-list-group--no-action":this.noAction,"v-list-group--sub-group":this.subGroup}}},watch:{isActive:function(t){!this.subGroup&&t&&this.list&&this.list.listClick(this._uid)},$route:"onRouteChange"},created:function(){this.list&&this.list.register(this),this.group&&this.$route&&null==this.value&&(this.isActive=this.matchRoute(this.$route.path))},beforeDestroy:function(){this.list&&this.list.unregister(this)},methods:{click:function(t){var e=this;this.disabled||(this.isBooted=!0,this.$emit("click",t),this.$nextTick((function(){return e.isActive=!e.isActive})))},genIcon:function(t){return this.$createElement(U["a"],t)},genAppendIcon:function(){var t=!this.subGroup&&this.appendIcon;return t||this.$slots.appendIcon?this.$createElement(F,{staticClass:"v-list-group__header__append-icon"},[this.$slots.appendIcon||this.genIcon(t)]):null},genHeader:function(){return this.$createElement(D,{staticClass:"v-list-group__header",attrs:{"aria-expanded":String(this.isActive),role:"button"},class:Object(H["a"])({},this.activeClass,this.isActive),props:{inputValue:this.isActive},directives:[{name:"ripple",value:this.ripple}],on:Object(B["a"])(Object(B["a"])({},this.listeners$),{},{click:this.click})},[this.genPrependIcon(),this.$slots.activator,this.genAppendIcon()])},genItems:function(){var t=this;return this.showLazyContent((function(){return[t.$createElement("div",{staticClass:"v-list-group__items",directives:[{name:"show",value:t.isActive}]},Object(M["l"])(t))]}))},genPrependIcon:function(){var t=this.subGroup&&null==this.prependIcon?"$subgroup":this.prependIcon;return t||this.$slots.prependIcon?this.$createElement(F,{staticClass:"v-list-group__header__prepend-icon"},[this.$slots.prependIcon||this.genIcon(t)]):null},onRouteChange:function(t){if(this.group){var e=this.matchRoute(t.path);e&&this.isActive!==e&&this.list&&this.list.listClick(this._uid),this.isActive=e}},toggle:function(t){var e=this,i=this._uid===t;i&&(this.isBooted=!0),this.$nextTick((function(){return e.isActive=i}))},matchRoute:function(t){return null!==t.match(this.group)}},render:function(t){return t("div",this.setTextColor(this.isActive&&this.color,{staticClass:"v-list-group",class:this.classes}),[this.genHeader(),t(Y["a"],this.genItems())])}}),i("899c"),i("604c")),et=Object(z["a"])(tt["a"],V["a"]).extend({name:"v-list-item-group",provide:function(){return{isInGroup:!0,listItemGroup:this}},computed:{classes:function(){return Object(B["a"])(Object(B["a"])({},tt["a"].options.computed.classes.call(this)),{},{"v-list-item-group":!0})}},methods:{genData:function(){return this.setTextColor(this.color,Object(B["a"])(Object(B["a"])({},tt["a"].options.methods.genData.call(this)),{},{attrs:{role:"listbox"}}))}}}),it=(J["a"].extend({name:"v-list-item-action",functional:!0,render:function(t,e){var i=e.data,s=e.children,o=void 0===s?[]:s;i.staticClass=i.staticClass?"v-list-item__action ".concat(i.staticClass):"v-list-item__action";var n=o.filter((function(t){return!1===t.isComment&&" "!==t.text}));return n.length>1&&(i.staticClass+=" v-list-item__action--stack"),t("div",i,o)}}),i("a9e3"),i("3408"),i("24b2")),st=i("a236"),ot=Object(z["a"])(V["a"],it["a"],st["a"]).extend({name:"v-avatar",props:{left:Boolean,right:Boolean,size:{type:[Number,String],default:48}},computed:{classes:function(){return Object(B["a"])({"v-avatar--left":this.left,"v-avatar--right":this.right},this.roundedClasses)},styles:function(){return Object(B["a"])({height:Object(M["f"])(this.size),minWidth:Object(M["f"])(this.size),width:Object(M["f"])(this.size)},this.measurableStyles)}},render:function(t){var e={staticClass:"v-avatar",class:this.classes,style:this.styles,on:this.$listeners};return t("div",this.setBackgroundColor(this.color,e),this.$slots.default)}}),nt=ot,at=(nt.extend({name:"v-list-item-avatar",props:{horizontal:Boolean,size:{type:[Number,String],default:40}},computed:{classes:function(){return Object(B["a"])(Object(B["a"])({"v-list-item__avatar--horizontal":this.horizontal},nt.options.computed.classes.call(this)),{},{"v-avatar--tile":this.tile||this.horizontal})}},render:function(t){var e=nt.options.render.call(this,t);return e.data=e.data||{},e.data.staticClass+=" v-list-item__avatar",e}}),Object(M["g"])("v-list-item__action-text","span"),Object(M["g"])("v-list-item__content","div")),lt=Object(M["g"])("v-list-item__title","div"),rt=(Object(M["g"])("v-list-item__subtitle","div"),i("0fd9")),ct=Object(g["a"])(j,_,p,!1,null,"3d83db25",null),ut=ct.exports;ct.options.components=Object.assign(Object.create(ct.options.components||null),ct.options.components||{},{QDialog:y["m"],QCard:y["g"],QCardSection:y["i"],QSpace:y["D"],QBtn:y["e"],QInput:y["q"]}),ct.options.directives=Object.assign(Object.create(ct.options.directives||null),ct.options.directives||{},{ClosePopup:y["a"]}),C()(ct,{VBtn:I["a"],VCol:q["a"],VIcon:A["a"],VListItem:D,VListItemContent:at,VListItemGroup:et,VListItemTitle:lt,VRow:rt["a"]});var dt={release:{buy:!0,buy_theav:!0,buy_content:!0,setting:!0,update_file:!1,upload_video:!1}},ht={price:0,content:"",upload_files:[]},_t={name:"thread",mixins:[h["a"]],components:{attach_content:ut},created:function(){var t=this;if(this.show_types=["videos"],window._t=this,!this.$store.state.hasLogin){this.$q.dialog({title:this.$l("title_board_message"),message:"对不起，请先登录",cancel:!1,ok:this.$l("login"),persistent:!0}).onOk((function(e){t.$router.push("/user/login")}));var e=this.$route.query.show_types;e&&(this.show_types=[],this.show_types.push(e))}this.create_editor(),this.forums_options=[],this.update_forums_options(this.$forum_conf.forums,this.forums_options);var i=this.getUrlVars();if(i.fid){var s=this.get_forum(i.fid);console.log("this_forum_conf:",s),s&&this.on_select_forum(s)}i.edit_id&&(this.edit_id=i.edit_id),console.log("forums_options:",this.forums_options)},data:function(){return{show_attach_content_dialog:!1,show_node_dialog:!1,editor_setting:{},loaded_quill:!1,editor:void 0,title:"",release_loading:!1,add_buy_content_open:!1,add_buy_download_open:!1,add_buy_theav_open:!1,attach_file_upload:void 0,thread:{title:"",setting:{not_reply:!1},fid:void 0},buy_download:{price:20},buy_content:Object.assign({},ht),buy_theav:{price:100,id:""},post_success:!1,post_success_tip:"恭喜你，已成功提交，请等待审核通过。",edit_id:"",show_loading:!1,forums_options:[],forums_options_disabled:!1,this_forum_conf:Object.create(dt),select_forum_conf:void 0,show_select_forum_text:void 0,post_response:void 0,buy_contents:[],show_types:["videos"]}},methods:{update_setting:function(){this.editor_setting.release=dt.release,this.this_forum_conf.release&&(this.editor_setting.release=this.this_forum_conf.release),this.this_forum_conf.setting&&(this.thread.setting=this.this_forum_conf.setting),this.$forceUpdate()},on_dialog_select_forum:function(t){this.on_select_forum(t),this.show_node_dialog=!1,this.$forceUpdate()},on_select_forum:function(t){this.select_forum_conf=this.this_forum_conf=t;var e=this.this_forum_conf.release;e||(e={}),this.this_forum_conf.release=Object.assign({},dt.release,e);var i=[];this.show_select_forum_text="",this.get_forum_list(this.select_forum_conf.fid,i);for(var s=0;s<i.length;++s)this.show_select_forum_text+=i[s]["name"]+"/";this.show_select_forum_text=this.show_select_forum_text.substr(0,this.show_select_forum_text.length-1),this.thread.fid=this.this_forum_conf.fid,this.update_setting()},on_release:function(){var t=this,e={thread_inner_html:this.editor.root.innerHTML,edit_id:this.edit_id,thread:this.thread};this.buy_contents&&this.buy_contents.length>0&&(e["buy_contents"]=this.buy_contents),this.add_buy_theav_open&&(e["buy_theav"]=this.buy_theav),this.release_loading=!0,this.$axios.post("/app/release/thread",e).then((function(e){t.release_loading=!1,e&&(t.post_success=!0,t.post_response=e),t.edit_id=e.data.id})).catch((function(e){t.release_loading=!1,t.$message("发布话题出错，请稍等再试或者联系我们。")}))},onReset:function(){},create_forum_list:function(){},on_select_node:function(){this.show_node_dialog=!1,this.show_node_dialog=!0,this.$forceUpdate()},add_buy_theav:function(){this.add_buy_theav_open=!this.add_buy_theav_open},show_edit:function(){var t=this;this.edit_id&&(console.log("show_edit:",this.edit_id),this.show_loading=!0,this.get_topic({id:this.edit_id,from_cache:!1,cb:function(e){t.thread=Object.assign(t.thread,e),t.thread.title=e.title,e.setting&&(t.thread.setting=e.setting),console.log("thread.content:",e.content),t.editor.root.innerHTML=e.content,console.log("thread.content2:"),e.buy_contents&&(t.buy_contents=e.buy_contents),console.log("this.buy_contents:",t.buy_contents),e.buy_theav&&(t.buy_theav=Object.assign(t.buy_theav,e.buy_theav),t.buy_theav.id&&(t.add_buy_theav_open=!0),t.thread.forum=e.fid,t.this_forum_conf=t.get_forum(e.fid),t.on_select_forum(t.this_forum_conf)),t.$forceUpdate(),t.show_loading=!1}}))},on_load_editor:function(){this.show_edit()},on_show_attach_content_dialog:function(t){var e=this;console.log("buy_content:",t),t||(t=Object.assign({},ht),t.upload_files=[]),t&&(this.buy_content=t),this.show_attach_content_dialog=!1,this.$nextTick((function(){e.show_attach_content_dialog=!0,e.$forceUpdate()})),this.$forceUpdate()},on_submit_buy_content:function(t){console.log("on_submit_buy_content:",t);for(var e=!0,i=0;i<this.buy_contents.length;++i)if(this.buy_contents[i]==t){e=!1;break}e&&this.buy_contents.push(t),console.log("[on_submit_buy_content] is_add:",e),this.$forceUpdate()},create_editor:function(){console.log("call create_editor");var t=window.Quill;t&&!this.loaded_quill&&(this.loaded_quill=!0);var e=window.ImageResize;if(!t||!e)return setTimeout(this.create_editor,100);var i=document.getElementById("editor");if(!i)return setTimeout(this.create_editor,100);if(!window.htmlEditButton)return setTimeout(this.create_editor,100);var s=[["bold","italic","underline","strike"],["blockquote","code-block"],[{direction:"rtl"}],[{header:[1,2,3,4,5,6,!1]}],[{color:[]},{background:[]}],[{align:[]}],["link","image"],["clean"]];try{t.register("modules/htmlEditButton",window.htmlEditButton);var o=t.import("blots/block"),a=function(t){Object(u["a"])(i,t);var e=Object(d["a"])(i);function i(){return Object(r["a"])(this,i),e.apply(this,arguments)}return Object(c["a"])(i,null,[{key:"formats",value:function(t){return i.tagName.indexOf(t.tagName)+1}}]),i}(o);a.blotName="header",a.tagName=["H1","H2"],t.register(a);var h=function(t){Object(u["a"])(i,t);var e=Object(d["a"])(i);function i(){return Object(r["a"])(this,i),e.apply(this,arguments)}return i}(o);h.tagName="div",h.blotName="div",h.allowedChildren=o.allowedChildren,h.allowedChildren.push(o),t.register(h);var _=t.import("blots/block/embed"),p=function(t){Object(u["a"])(i,t);var e=Object(d["a"])(i);function i(){return Object(r["a"])(this,i),e.apply(this,arguments)}return Object(c["a"])(i,[{key:"format",value:function(t,e){"height"===t||"width"===t?e?this.domNode.setAttribute(t,e):this.domNode.removeAttribute(t,e):l(Object(n["a"])(i.prototype),"format",this).call(this,t,e)}}],[{key:"create",value:function(t){var e=l(Object(n["a"])(i),"create",this).call(this);return e.setAttribute("src",t),e.setAttribute("frameborder","0"),e.setAttribute("allowfullscreen",!0),e}},{key:"formats",value:function(t){var e={};return t.hasAttribute("height")&&(e.height=t.getAttribute("height")),t.hasAttribute("width")&&(e.width=t.getAttribute("width")),e}},{key:"value",value:function(t){return t.getAttribute("src")}}]),i}(_);p.blotName="video",p.tagName="iframe",t.register(p);try{this.editor=new t("#editor",{modules:{toolbar:s,htmlEditButton:{msg:"修改HTML源码",okText:"确定",cancelText:"取消",buttonHTML:"<>",buttonTitle:"显示HTML源码",syntax:!1},imageResize:{displayStyles:{backgroundColor:"black",border:"none",color:"white"},displaySize:!0}},theme:"snow"})}catch(f){console.error("[new Quill]e:",f),location.reload()}this.on_load_editor()}catch(f){console.log("create editor error:",f)}}}},pt=_t,ft=(i("b853"),Object(g["a"])(pt,s,o,!1,null,null,null));e["default"]=ft.exports;ft.options.components=Object.assign(Object.create(ft.options.components||null),ft.options.components||{},{QCardSection:y["i"],QSkeleton:y["B"],QBtn:y["e"],QMenu:y["w"],QList:y["v"],QItem:y["r"],QItemSection:y["s"],QIcon:y["o"],QSeparator:y["A"],QInput:y["q"],QCheckbox:y["j"]}),ft.options.directives=Object.assign(Object.create(ft.options.directives||null),ft.options.directives||{},{ClosePopup:y["a"]}),C()(ft,{VBtn:I["a"],VCol:q["a"],VIcon:A["a"],VRow:rt["a"]})},f0ff:function(t,e,i){}}]);
//# sourceMappingURL=chunk-97846336.497954c7.js.map |
import { TextureLoader, NearestFilter, Vector2 } from "three";
export class RenderTileset {
constructor(tileset, texture, renderer) {
this._tileset = tileset;
this.texture = texture;
this._renderer = renderer;
}
static load(tileset, renderer) {
const resolveTexture = (resolve, texture) => {
texture.name = `Tileset ${tileset.name}`;
texture.magFilter = texture.minFilter = NearestFilter;
texture.generateMipmaps = false;
resolve(new RenderTileset(tileset, texture, renderer));
};
if (tileset.tilesetType === "ortho") {
return new Promise((resolve, reject) => {
const texture = new TextureLoader().load(tileset.url, () => {
resolveTexture(resolve, texture);
}, undefined, e => {
reject(e);
});
});
} else if (tileset.tilesetType === "test") {
return new Promise((resolve, reject) => {
const testTileset = generateTestImage(
tileset.name || "a",
25, 25,
tileset.tileWidth, tileset.tileHeight
);
const texture = new TextureLoader().load(testTileset, () => {
resolveTexture(resolve, texture);
}, undefined, e => {
reject(e);
});
});
} else {
console.error(`Unknown tileset type ${tileset.tilesetType}`);
}
}
getTileUvs(id) {
if (id === -1) {
const v = new Vector2(-1, -1);
return makeTrisFromQuad([v, v, v, v]);
}
const array = [];
const tileWidth = this._tileset.tileWidth,
tileHeight = this._tileset.tileHeight,
textureWidth = this.texture.image.width,
textureHeight = this.texture.image.height,
width = textureWidth / tileWidth,
y = Math.floor(id / width),
x = Math.floor(id - y * width);
for (let ly = y; ly < y + 2; ly++) {
for (let lx = x; lx < x + 2; lx++) {
array.push(new Vector2(
lx * tileWidth / textureWidth,
ly * tileHeight / textureHeight * -1 + 1
));
}
}
return makeTrisFromQuad(array);
}
}
function makeTrisFromQuad(quad) {
return [
[quad[0], quad[2], quad[1]],
[quad[2], quad[3], quad[1]]
];
}
function generateTestImage(seed, width, height, tileWidth, tileHeight) {
const canvas = document.createElement("canvas");
canvas.width = width * tileWidth;
canvas.height = height * tileHeight;
const context = canvas.getContext("2d");
randomSeed = seed.split("").reduce((acc, string) => acc + string.charCodeAt(0), 0);
for (let y = 0; y < height; y++) {
for (let x = 0; x < width; x++) {
context.fillStyle = "#" + ("000000" +
(Math.floor(random() * 0xffffff))).substr(-6);
context.fillRect(
x * tileWidth, y * tileHeight,
(x + 1) * tileWidth, (y + 1) * tileHeight
);
}
}
return canvas.toDataURL();
}
let randomSeed = 0;
function random() {
const x = Math.sin(randomSeed++) * 10000;
return x - Math.floor(x);
}
|
#! /usr/bin/env python
import tensorflow as tf
import numpy as np
import os
import time
import datetime
import data_helpers
from text_cnn import TextCNN
from tensorflow.contrib import learn
# Parameters
# ==================================================
# Data loading params
tf.flags.DEFINE_float("dev_sample_percentage", .15, "Percentage of the training data to use for validation")
tf.flags.DEFINE_string("data_file", "./train.csv", "Data source.")
# Model Hyperparameters
tf.flags.DEFINE_integer("embedding_dim", 128, "Dimensionality of character embedding (default: 128)")
tf.flags.DEFINE_string("filter_sizes", "3,4,5", "Comma-separated filter sizes (default: '3,4,5')")
tf.flags.DEFINE_integer("num_filters", 128, "Number of filters per filter size (default: 128)")
tf.flags.DEFINE_float("dropout_keep_prob", 0.5, "Dropout keep probability (default: 0.5)")
tf.flags.DEFINE_float("l2_reg_lambda", 0.0, "L2 regularization lambda (default: 0.0)")
# Training parameters
tf.flags.DEFINE_integer("batch_size", 64, "Batch Size (default: 64)")
tf.flags.DEFINE_integer("num_epochs", 200, "Number of training epochs (default: 200)")
tf.flags.DEFINE_integer("evaluate_every", 100, "Evaluate model on dev set after this many steps (default: 100)")
tf.flags.DEFINE_integer("checkpoint_every", 100, "Save model after this many steps (default: 100)")
tf.flags.DEFINE_integer("num_checkpoints", 5, "Number of checkpoints to store (default: 5)")
# Misc Parameters
tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement")
tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices")
FLAGS = tf.flags.FLAGS
# FLAGS._parse_flags()
# print("\nParameters:")
# for attr, value in sorted(FLAGS.__flags.items()):
# print("{}={}".format(attr.upper(), value))
# print("")
def preprocess():
# Data Preparation
# ==================================================
# Load data
print("Loading data...")
x_text, y = data_helpers.load_data_and_labels(FLAGS.data_file)
# Build vocabulary
max_document_length = max([len(x.split(" ")) for x in x_text])
vocab_processor = learn.preprocessing.VocabularyProcessor(max_document_length)
x = np.array(list(vocab_processor.fit_transform(x_text)))
# Randomly shuffle data
np.random.seed(10)
shuffle_indices = np.random.permutation(np.arange(len(y)))
x_shuffled = x[shuffle_indices]
y_shuffled = y[shuffle_indices]
# Split train/test set
# TODO: This is very crude, should use cross-validation
dev_sample_index = -1 * int(FLAGS.dev_sample_percentage * float(len(y)))
x_train, x_dev = x_shuffled[:dev_sample_index], x_shuffled[dev_sample_index:]
y_train, y_dev = y_shuffled[:dev_sample_index], y_shuffled[dev_sample_index:]
del x, y, x_shuffled, y_shuffled
print("Vocabulary Size: {:d}".format(len(vocab_processor.vocabulary_)))
print("Train/Dev split: {:d}/{:d}".format(len(y_train), len(y_dev)))
return x_train, y_train, vocab_processor, x_dev, y_dev
def train(x_train, y_train, vocab_processor, x_dev, y_dev):
# Training
# ==================================================
with tf.Graph().as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default():
cnn = TextCNN(
sequence_length=x_train.shape[1],
num_classes=y_train.shape[1],
vocab_size=len(vocab_processor.vocabulary_),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda)
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in grads_and_vars:
if g is not None:
grad_hist_summary = tf.summary.histogram("{}/grad/hist".format(v.name), g)
sparsity_summary = tf.summary.scalar("{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g))
grad_summaries.append(grad_hist_summary)
grad_summaries.append(sparsity_summary)
grad_summaries_merged = tf.summary.merge(grad_summaries)
# Output directory for models and summaries
timestamp = str(int(time.time()))
out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", timestamp))
print("Writing to {}\n".format(out_dir))
# Summaries for loss and accuracy
loss_summary = tf.summary.scalar("loss", cnn.loss)
acc_summary = tf.summary.scalar("accuracy", cnn.accuracy)
# Train Summaries
train_summary_op = tf.summary.merge([loss_summary, acc_summary, grad_summaries_merged])
train_summary_dir = os.path.join(out_dir, "summaries", "train")
train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)
# Dev summaries
dev_summary_op = tf.summary.merge([loss_summary, acc_summary])
dev_summary_dir = os.path.join(out_dir, "summaries", "dev")
dev_summary_writer = tf.summary.FileWriter(dev_summary_dir, sess.graph)
# Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it
checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints)
# Write vocabulary
vocab_processor.save(os.path.join(out_dir, "vocab"))
# Initialize all variables
sess.run(tf.global_variables_initializer())
def train_step(x_batch, y_batch):
"""
A single training step
"""
feed_dict = {
cnn.input_x: x_batch,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: FLAGS.dropout_keep_prob
}
_, step, summaries, loss, accuracy = sess.run(
[train_op, global_step, train_summary_op, cnn.loss, cnn.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
train_summary_writer.add_summary(summaries, step)
def dev_step(x_batch, y_batch, writer=None):
"""
Evaluates model on a dev set
"""
feed_dict = {
cnn.input_x: x_batch,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: 1.0
}
step, summaries, loss, accuracy = sess.run(
[global_step, dev_summary_op, cnn.loss, cnn.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
if writer:
writer.add_summary(summaries, step)
# Generate batches
batches = data_helpers.batch_iter(
list(zip(x_train, y_train)), FLAGS.batch_size, FLAGS.num_epochs)
# Training loop. For each batch...
for batch in batches:
x_batch, y_batch = zip(*batch)
train_step(x_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % FLAGS.evaluate_every == 0:
print("\nEvaluation:")
dev_step(x_dev, y_dev, writer=dev_summary_writer)
print("")
if current_step % FLAGS.checkpoint_every == 0:
path = saver.save(sess, checkpoint_prefix, global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
def main(argv=None):
x_train, y_train, vocab_processor, x_dev, y_dev = preprocess()
train(x_train, y_train, vocab_processor, x_dev, y_dev)
if __name__ == '__main__':
tf.app.run() |
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
from pandas import DataFrame
from nnlib.classifiers.cnn_fft_1D import ThreeLayerConvNetFFT1D
from nnlib.load_time_series import load_data
from nnlib.solver import Solver
from nnlib.utils.general_utils import *
class Result(object):
def __init__(self, data):
self.data = data
current_file_name = __file__.split("/")[-1].split(".")[0]
print("current file name: ", current_file_name)
dataset = "50words"
datasets = load_data(dataset)
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
def reshape(x):
return np.array(x.reshape(1, -1))
train_set_x_reshaped = np.empty([len(train_set_x), 1, len(train_set_x[0])])
valid_set_x_reshaped = np.empty([len(valid_set_x), 1, len(valid_set_x[0])])
index = 0
for x in train_set_x:
train_set_x_reshaped[index] = reshape(x)
index = 0
for x in valid_set_x:
valid_set_x_reshaped[index] = reshape(x)
# small_data = {
# 'X_train': train_set_x_reshaped[:10],
# 'y_train': train_set_y[:10],
# 'X_val': valid_set_x_reshaped[:10],
# 'y_val': valid_set_y[:10],
# }
small_data = {
'X_train': train_set_x_reshaped,
'y_train': train_set_y,
'X_val': valid_set_x_reshaped,
'y_val': valid_set_y,
}
import time
time.sleep(10000)
num_epochs = 1200
energy_rates = [None, 1.0, 0.99, 0.98, 0.95]
losses_rate = []
print_every = 100
for energy_rate in energy_rates:
print("energy rate: ", energy_rate)
start = time.time()
model = ThreeLayerConvNetFFT1D(weight_scale=1e-2, energy_rate_convolution=energy_rate)
solver = Solver(model, small_data,
num_epochs=num_epochs, batch_size=50,
update_rule='adam',
optim_config={
'learning_rate': 1e-3,
},
verbose=True, print_every=print_every)
solver.train()
elapsed_time = time.time() - start
losses_rate.append((solver.train_acc_history, solver.val_acc_history, energy_rate, solver.loss_history,
elapsed_time))
print("energy rate: ", solver.num_epochs)
print("loss history: ", solver.loss_history)
print("train acc: ", solver.train_acc_history)
print("val acc: ", solver.val_acc_history)
print("elapsed time: ", elapsed_time)
data = losses_rate
result = Result(data)
pickle_name = "results/" + current_file_name + "-" + get_log_time() + ".pkl"
print("pickle name: ", pickle_name)
save_object(result, pickle_name)
# get current file name
# import matplotlib.pyplot as plt
# import os
#
# epochs = 5
# energy1 = [1, 2, 3, 4, 5]
# energy2 = [1, 2, 1, 3, 4]
# energy3 = [0, 0, 2, 3, 10]
# energies = [(energy1, 0.99), (energy2, 0.90), (energy3, 0.80)]
epochs = [epoch for epoch in range(num_epochs)]
fig, ax = plt.subplots()
for train_acc, val_acc, rate, _, _ in losses_rate:
train_label = "train-" + str(rate)
ax.plot([x for x in range(len(train_acc))], train_acc, label=train_label)
val_label = "validation-" + str(rate)
ax.plot([x for x in range(len(val_acc))], val_acc, label=val_label)
ax.legend()
plt.xticks(epochs)
plt.title('Compare accuracy for fft convolution with different preserved energy rates')
plt.xlabel('Epoch')
plt.ylabel('Train/Validation accuracy')
plt.savefig("graphs/train-val-" + current_file_name + "-" + get_log_time() + ".png")
plt.gcf().subplots_adjust(bottom=0.10)
plt.savefig("graphs/train-val-" + current_file_name + "-" + get_log_time() + ".pdf")
# plt.show()
fig, ax = plt.subplots()
for _, _, rate, losses, _ in losses_rate:
ax.plot([x for x in range(len(losses))], losses, label=str(rate))
ax.legend()
plt.title('Compare loss for fft convolution with different preserved energy rates')
plt.xlabel('Time step')
plt.ylabel('Train loss')
plt.savefig("graphs/losses-" + current_file_name + "-" + get_log_time() + ".png")
plt.gcf().subplots_adjust(bottom=0.10)
plt.savefig("graphs/losses-" + current_file_name + "-" + get_log_time() + ".pdf")
# plt.show()
# import matplotlib.patches as mpatches
# import matplotlib.pyplot as plt
# from pandas import DataFrame
# current_file_name = ""
#
# losses_rate = [([], [], 1.0, [], 3.0), ([], [], 0.9, [], 7.9)]
trates = []
ttimes = []
for _, _, rate, _, timing in losses_rate:
print(timing)
trates.append(rate)
ttimes.append(timing)
# print("timings: ", ttimes)
# print("trates: ", trates)
df_input = {'rates': trates, 'ttimes': ttimes}
df = DataFrame(data=df_input)
df = df.astype(float)
# print("df: ", df)
fig = plt.figure() # create matplot figure
ax = fig.add_subplot(111) # create matplotlib axes
width = 1.0
df.ttimes.plot(kind='bar', color='red', ax=ax)
left_ylabel = "Execution time (sec)"
ax.set_ylabel(left_ylabel, color="red")
ax.tick_params('y', colors='red')
plt.title("Execution time (sec) for each preserved energy rate")
ax.set_xticklabels(trates)
ax.set_xlabel("Preserved energy rate")
red_patch = mpatches.Patch(color='red', label=left_ylabel)
plt.legend(handles=[red_patch], loc='upper right', ncol=1,
borderaxespad=0.0)
plt.savefig("graphs/timing-" + current_file_name + "-" + get_log_time() + ".png")
plt.gcf().subplots_adjust(bottom=0.20)
plt.savefig("graphs/timing-" + current_file_name + "-" + get_log_time() + ".pdf")
# plt.show()
|
##
# from https://github.com/jojonki/word2vec-pytorch/blob/master/word2vec.ipynb
# Migrated to > 0.4.0 pytorch
##
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
class CBOW(nn.Module):
def __init__(self, vocab_size, embd_size, context_size, hidden_size):
super(CBOW, self).__init__()
self.embeddings = nn.Embedding(vocab_size, embd_size)
self.linear1 = nn.Linear(2*context_size*embd_size, hidden_size)
self.linear2 = nn.Linear(hidden_size, vocab_size)
def forward(self, inputs):
embedded = self.embeddings(inputs).view((1, -1))
hid = F.relu(self.linear1(embedded))
out = self.linear2(hid)
log_probs = F.log_softmax(out)
return log_probs
class SkipGram(nn.Module):
def __init__(self, vocab_size, embd_size):
super(SkipGram, self).__init__()
self.embeddings = nn.Embedding(vocab_size, embd_size)
def forward(self, focus, context):
embed_focus = self.embeddings(focus).view((1, -1))
embed_ctx = self.embeddings(context).view((1, -1))
score = torch.mm(embed_focus, torch.t(embed_ctx))
log_probs = F.logsigmoid(score)
return log_probs
SEED = 1234
torch.manual_seed(SEED)
CONTEXT_SIZE = 2
text = """We are about to study the idea of a computational process.
Computational processes are abstract beings that inhabit computers.
As they evolve, processes manipulate other abstract things called data.
The evolution of a process is a directed by a pattern of rules called a program.
People create programs to direct process. In effect, we conjure the spirits of the computer with our spels.""".split()
split_ind = (int)(len(text) * 0.8)
vocab = set(text)
vocab_size = len(vocab)
print('vocab_size:', vocab_size)
w2i = {w: i for i, w in enumerate(vocab)}
i2w = {i: w for i, w in enumerate(vocab)}
def create_cbow_dataset(text):
data = []
for i in range(2, len(text) - 2):
context = [text[i - 2], text[i - 1],
text[i + 1], text[i + 2]]
target = text[i]
data.append((context, target))
return data
def create_skipgram_dataset(text):
import random
data = []
for i in range(2, len(text) - 2):
data.append((text[i], text[i-2], 1))
data.append((text[i], text[i-1], 1))
data.append((text[i], text[i+1], 1))
data.append((text[i], text[i+2], 1))
for _ in range(4):
if random.random() < 0.5 or i >= len(text) - 3:
rand_id = random.randint(0, i-1)
else:
rand_id = random.randint(i+3, len(text) - 1)
data.append((text[i], text[rand_id], 0))
return data
cbow_train = create_cbow_dataset(text)
skipgram_train = create_skipgram_dataset(text)
print('CBOW sample: ', cbow_train[0])
print('skipgram sample: ', skipgram_train[0])
embd_size = 100
learning_rate = 0.001
n_epoch = 30
def train_cbow():
hidden_size = 64
losses = []
loss_fn = nn.NLLLoss()
model = CBOW(vocab_size, embd_size, CONTEXT_SIZE, hidden_size)
print(model)
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
for epoch in range(n_epoch):
total_loss = .0
for context, target in cbow_train:
ctx_idxs = [w2i[w] for w in context]
ctx_var = Variable(torch.LongTensor(ctx_idxs))
model.zero_grad()
log_probs = model(ctx_var)
loss = loss_fn(log_probs, Variable(torch.LongTensor([w2i[target]])))
loss.backward()
optimizer.step()
total_loss += loss.item()
losses.append(total_loss)
return model, losses
def train_skipgram():
losses = []
loss_fn = nn.MSELoss()
model = SkipGram(vocab_size, embd_size)
print(model)
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
for epoch in range(n_epoch):
total_loss = .0
for in_w, out_w, target in skipgram_train:
in_w_var = Variable(torch.LongTensor([w2i[in_w]]))
out_w_var = Variable(torch.LongTensor([w2i[out_w]]))
model.zero_grad()
log_probs = model(in_w_var, out_w_var)
loss = loss_fn(log_probs[0], Variable(torch.Tensor([target])))
loss.backward()
optimizer.step()
total_loss += loss.item()
losses.append(total_loss)
return model, losses
cbow_model, cbow_losses = train_cbow()
sg_model, sg_losses = train_skipgram()
def test_cbow(test_data, model):
print('===TEST CBOW===')
correct_ct = 0
for ctx, target in test_data:
ctx_idxs = [w2i[w] for w in ctx]
ctx_var = Variable(torch.LongTensor(ctx_idxs))
model.zero_grad()
log_probs = model(ctx_var)
_, predicted = torch.max(log_probs.data, 1)
predicted_word = i2w[predicted[0]]
print('predicted: ', predicted_word)
print('label : ', target)
if predicted_word == target:
correct_ct += 1
print('Accuracy: {:.1f}% ({:d})/({:d})'.format(correct_ct/len(test_data)*100, correct_ct, len(test_data)))
def test_skipgram(test_data, model):
print('====TEST SKIPGRAM====')
correct_ct = 0
for in_w, out_w, target in test_data:
in_w_var = Variable(torch.LongTensor([w2i[in_w]]))
out_w_var = Variable(torch.LongTensor([w2i[out_w]]))
model.zero_grad()
log_probs = model(in_w_var, out_w_var)
_, predicted = torch.max(log_probs.data, 1)
predicted = predicted[0]
if predicted == target:
correct_ct += 1
print('Accuracy: {:.1f}% ({:d})/({:d})'.format(correct_ct/len(test_data*100, correct_ct, len(test_data))))
test_cbow(cbow_train, cbow_model)
print('-----')
test_skipgram(skipgram_train, sg_model) |
"""Misc. tests that don't fit anywhere.
XXX: Try our best to reduce tests in this file.
"""
import os
from tempfile import mkdtemp
import mock
import pytest
from pipenv._compat import Path
from pipenv.project import Project
from pipenv.utils import temp_environ
from pipenv.vendor import delegator
@pytest.mark.code
@pytest.mark.install
@pytest.mark.skip(reason='non deterministic')
def test_code_import_manual(PipenvInstance):
with PipenvInstance(chdir=True) as p:
with open('t.py', 'w') as f:
f.write('import requests')
p.pipenv('install -c .')
assert 'requests' in p.pipfile['packages']
@pytest.mark.lock
@pytest.mark.deploy
@pytest.mark.cli
def test_deploy_works(PipenvInstance, pypi):
with PipenvInstance(pypi=pypi, chdir=True) as p:
with open(p.pipfile_path, 'w') as f:
contents = """
[packages]
requests = "==2.14.0"
flask = "==0.12.2"
[dev-packages]
pytest = "==3.1.1"
""".strip()
f.write(contents)
c = p.pipenv('install --verbose')
if c.return_code != 0:
assert c.err == '' or c.err is None
assert c.out == ''
assert c.return_code == 0
c = p.pipenv('lock')
assert c.return_code == 0
with open(p.pipfile_path, 'w') as f:
contents = """
[packages]
requests = "==2.14.0"
""".strip()
f.write(contents)
c = p.pipenv('install --deploy')
assert c.return_code > 0
@pytest.mark.update
@pytest.mark.lock
def test_update_locks(PipenvInstance, pypi):
with PipenvInstance(pypi=pypi) as p:
c = p.pipenv('install requests==2.14.0')
assert c.return_code == 0
with open(p.pipfile_path, 'r') as fh:
pipfile_contents = fh.read()
pipfile_contents = pipfile_contents.replace('==2.14.0', '*')
with open(p.pipfile_path, 'w') as fh:
fh.write(pipfile_contents)
c = p.pipenv('update requests')
assert c.return_code == 0
assert p.lockfile['default']['requests']['version'] == '==2.19.1'
c = p.pipenv('run pip freeze')
assert c.return_code == 0
lines = c.out.splitlines()
assert 'requests==2.19.1' in [l.strip() for l in lines]
@pytest.mark.project
@pytest.mark.proper_names
def test_proper_names_unamanged_virtualenv(PipenvInstance, pypi):
with PipenvInstance(chdir=True, pypi=pypi):
c = delegator.run('python -m virtualenv .venv')
assert c.return_code == 0
project = Project()
assert project.proper_names == []
@pytest.mark.cli
def test_directory_with_leading_dash(PipenvInstance):
def mocked_mkdtemp(suffix, prefix, dir):
if suffix == '-project':
prefix = '-dir-with-leading-dash'
return mkdtemp(suffix, prefix, dir)
with mock.patch('pipenv.vendor.vistir.compat.mkdtemp', side_effect=mocked_mkdtemp):
with temp_environ(), PipenvInstance(chdir=True) as p:
del os.environ['PIPENV_VENV_IN_PROJECT']
p.pipenv('--python python')
venv_path = p.pipenv('--venv').out.strip()
assert os.path.isdir(venv_path)
# Manually clean up environment, since PipenvInstance assumes that
# the virutalenv is in the project directory.
p.pipenv('--rm')
|
// Max van Leeuwen
// ig @max.van.leeuwen
// twitter @maksvanleeuwen
//
// Starts animation on tap
// It uses all default settings,
// e.g. duration = 1s, animation curve = Cubic|InOut
// create new animation instance
var anim = new global.AnimateProperty();
// the function to call on each animation frame, this moves the block
anim.updateFunction = function(v){
// updateFunction is always called with one argument, a 0-1 ratio of how far the animation has progressed. this is used to move the object like so:
script.getTransform().setWorldPosition(new vec3(v*100, 0, 0)); // move this object somewhere
};
// reverse the animation direction when animation is stopped, this makes the block ping-pong on each tap
anim.endFunction = function(){
anim.setReversed(!anim.getReversed())
};
// interaction
function onTap(){ // when the user taps on the screen
anim.stop(); // stop currently running animation (if any), will call the endFunction() callback
anim.start(); // start
}
var onTapEvent = script.createEvent("TapEvent");
onTapEvent.bind(onTap); |
"use strict";
// Copyright 2020 Google LLC
// 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.
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/class-name-casing */
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/no-empty-interface */
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable no-irregular-whitespace */
const googleapis_common_1 = require("googleapis-common");
var keep_v1;
(function (keep_v1) {
/**
* Google Keep API
*
* This API is an enterprise-only API used to create and manage the Keep notes within your domain, including resolving issues identified by CASB software.
*
* @example
* ```js
* const {google} = require('googleapis');
* const keep = google.keep('v1');
* ```
*/
class Keep {
constructor(options, google) {
this.context = {
_options: options || {},
google,
};
this.media = new Resource$Media(this.context);
this.notes = new Resource$Notes(this.context);
}
}
keep_v1.Keep = Keep;
class Resource$Media {
constructor(context) {
this.context = context;
}
download(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback || {});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
method: 'GET',
}, options),
params,
requiredParams: ['name'],
pathParams: ['name'],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
}
keep_v1.Resource$Media = Resource$Media;
class Resource$Notes {
constructor(context) {
this.context = context;
this.permissions = new Resource$Notes$Permissions(this.context);
}
create(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback || {});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/notes').replace(/([^:]\/)\/+/g, '$1'),
method: 'POST',
}, options),
params,
requiredParams: [],
pathParams: [],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
delete(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback || {});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
method: 'DELETE',
}, options),
params,
requiredParams: ['name'],
pathParams: ['name'],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
get(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback || {});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
method: 'GET',
}, options),
params,
requiredParams: ['name'],
pathParams: ['name'],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
list(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback || {});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/notes').replace(/([^:]\/)\/+/g, '$1'),
method: 'GET',
}, options),
params,
requiredParams: [],
pathParams: [],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
}
keep_v1.Resource$Notes = Resource$Notes;
class Resource$Notes$Permissions {
constructor(context) {
this.context = context;
}
batchCreate(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback ||
{});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/{+parent}/permissions:batchCreate').replace(/([^:]\/)\/+/g, '$1'),
method: 'POST',
}, options),
params,
requiredParams: ['parent'],
pathParams: ['parent'],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
batchDelete(paramsOrCallback, optionsOrCallback, callback) {
let params = (paramsOrCallback ||
{});
let options = (optionsOrCallback || {});
if (typeof paramsOrCallback === 'function') {
callback = paramsOrCallback;
params = {};
options = {};
}
if (typeof optionsOrCallback === 'function') {
callback = optionsOrCallback;
options = {};
}
const rootUrl = options.rootUrl || 'https://keep.googleapis.com/';
const parameters = {
options: Object.assign({
url: (rootUrl + '/v1/{+parent}/permissions:batchDelete').replace(/([^:]\/)\/+/g, '$1'),
method: 'POST',
}, options),
params,
requiredParams: ['parent'],
pathParams: ['parent'],
context: this.context,
};
if (callback) {
googleapis_common_1.createAPIRequest(parameters, callback);
}
else {
return googleapis_common_1.createAPIRequest(parameters);
}
}
}
keep_v1.Resource$Notes$Permissions = Resource$Notes$Permissions;
})(keep_v1 = exports.keep_v1 || (exports.keep_v1 = {}));
//# sourceMappingURL=v1.js.map |
import context from '../../context'
import ActiveModel from '../ActiveModel'
import { findById, updateById } from '../../helpers'
const coll = () => context.users
class User extends ActiveModel {
constructor (params = {}) {
super(params)
// These fields have a lot of overlap and it's a bit unclear what is needed and what is not.
// We should clean this up once we can figure out more specifically what fields should be used.
this.displayname = params.displayname || params.name || params.email || ''
this.name = params.name || params.email || ''
this.email = params.email || ''
this.mfa = params.mfa || false
this.password = params.password
this.roles = params.roles || []
this.tenantId = params.tenantId || ''
this.username = params.username || params.name || params.email || ''
this.rolePair = params.rolePair || []
}
static getCollection = coll
static clearCollection = () => coll().splice(0, coll().length)
static findById = findById(coll)
static updateById = updateById(coll)
static findByUsername = username => User.getCollection().find(x => x.username === username)
static getAuthenticatedUser = (username, password) => {
const user = User.findByUsername(username)
if (!user) {
return null
}
const attemptedPassword = `${password}${user.mfa || ''}`
return user.password === attemptedPassword ? user : null
}
// TODO
getTenants = () => []
addRole = (tenant, role) => this.roles.push({ tenant, role })
asJson = () => {
return {
...super.asJson(),
displayname: this.displayname,
email: this.email,
name: this.name,
username: this.username,
tenantId: this.tenantId,
roles: this.roles,
rolePair: this.rolePair
}
}
}
export default User
|
# # game_test.py
# from game import determine_winner
# def test_determination_of_the_winner():
# assert determine_winner("rock", "rock") == None # represents a tie
# assert determine_winner("rock", "paper") == "paper"
# assert determine_winner("rock", "scissors") == "rock"
# assert determine_winner("paper", "rock") == "paper"
# assert determine_winner("paper", "paper") == None # represents a tie
# assert determine_winner("paper", "scissors") == "scissors"
# assert determine_winner("scissors", "rock") == "rock"
# assert determine_winner("scissors", "paper") == "scissors"
# assert determine_winner("scissors", "scissors") == None # represents a tie
# def test_my_thing():
# assert 2 == 2
# def test_my_thing2():
# assert 2 == 3
# NEED TO INCLUDE "ASSERT" IN TESTS
def test_my_thing():
assert 2 == 2
|
function convert_uuencode(str) {
// discuss at: http://phpjs.org/functions/convert_uuencode/
// original by: Ole Vrijenhoek
// bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
// bugfixed by: Brett Zamir (http://brett-zamir.me)
// reimplemented by: Ole Vrijenhoek
// depends on: is_scalar
// example 1: convert_uuencode("test\ntext text\r\n");
// returns 1: "0=&5S=`IT97AT('1E>'0-\"@``"
var chr = function(c) {
return String.fromCharCode(c);
};
if (!str || str === '') {
return chr(0);
} else if (!this.is_scalar(str)) {
return false;
}
var c = 0,
u = 0,
i = 0,
a = 0;
var encoded = '',
tmp1 = '',
tmp2 = '',
bytes = {};
// divide string into chunks of 45 characters
var chunk = function() {
bytes = str.substr(u, 45);
for (i in bytes) {
bytes[i] = bytes[i].charCodeAt(0);
}
if (bytes.length != 0) {
return bytes.length;
} else {
return 0;
}
};
while (chunk() !== 0) {
c = chunk();
u += 45;
// New line encoded data starts with number of bytes encoded.
encoded += chr(c + 32);
// Convert each char in bytes[] to a byte
for (i in bytes) {
tmp1 = bytes[i].charCodeAt(0)
.toString(2);
while (tmp1.length < 8) {
tmp1 = '0' + tmp1;
}
tmp2 += tmp1;
}
while (tmp2.length % 6) {
tmp2 = tmp2 + '0';
}
for (i = 0; i <= (tmp2.length / 6) - 1; i++) {
tmp1 = tmp2.substr(a, 6);
if (tmp1 == '000000') {
encoded += chr(96);
} else {
encoded += chr(parseInt(tmp1, 2) + 32);
}
a += 6;
}
a = 0;
tmp2 = '';
encoded += '\n';
}
// Add termination characters
encoded += chr(96) + '\n';
return encoded;
} |
#*******************************************************************************
# Copyright 2014-2020 Intel Corporation
# All Rights Reserved.
#
# This software is licensed under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# 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.
#*******************************************************************************
# daal4py Linear Regression example for shared memory systems
import daal4py as d4p
import numpy as np
import os
from daal4py.oneapi import sycl_context, sycl_buffer
# let's try to use pandas' fast csv reader
try:
import pandas
read_csv = lambda f, c, t=np.float64: pandas.read_csv(f, usecols=c, delimiter=',', header=None, dtype=t)
except:
# fall back to numpy loadtxt
read_csv = lambda f, c, t=np.float64: np.loadtxt(f, usecols=c, delimiter=',', ndmin=2)
try:
with sycl_context('gpu'):
gpu_available=True
except:
gpu_available=False
# Commone code for both CPU and GPU computations
def compute(train_indep_data, train_dep_data, test_indep_data):
# Configure a Linear regression training object
train_algo = d4p.linear_regression_training(interceptFlag=True)
# Now train/compute, the result provides the model for prediction
train_result = train_algo.compute(train_indep_data, train_dep_data)
# Now let's do some prediction
predict_algo = d4p.linear_regression_prediction()
# now predict using the model from the training above
return predict_algo.compute(test_indep_data, train_result.model), train_result
# At this moment with sycl we are working only with numpy arrays
def to_numpy(data):
try:
from pandas import DataFrame
if isinstance(data, DataFrame):
return np.ascontiguousarray(data.values)
except:
pass
try:
from scipy.sparse import csr_matrix
if isinstance(data, csr_matrix):
return data.toarray()
except:
pass
return data
def main(readcsv=read_csv, method='defaultDense'):
# read training data. Let's have 10 independent, and 2 dependent variables (for each observation)
trainfile = os.path.join('..', 'data', 'batch', 'linear_regression_train.csv')
train_indep_data = readcsv(trainfile, range(10))
train_dep_data = readcsv(trainfile, range(10,12))
# read testing data
testfile = os.path.join('..', 'data', 'batch', 'linear_regression_test.csv')
test_indep_data = readcsv(testfile, range(10))
test_dep_data = readcsv(testfile, range(10,12))
# Using of the classic way (computations on CPU)
result_classic, train_result = compute(train_indep_data, train_dep_data, test_indep_data)
train_indep_data = to_numpy(train_indep_data)
train_dep_data = to_numpy(train_dep_data)
test_indep_data = to_numpy(test_indep_data)
# It is possible to specify to make the computations on GPU
if gpu_available:
with sycl_context('gpu'):
sycl_train_indep_data = sycl_buffer(train_indep_data)
sycl_train_dep_data = sycl_buffer(train_dep_data)
sycl_test_indep_data = sycl_buffer(test_indep_data)
result_gpu, _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data)
assert np.allclose(result_classic.prediction, result_gpu.prediction)
# It is possible to specify to make the computations on CPU
with sycl_context('cpu'):
sycl_train_indep_data = sycl_buffer(train_indep_data)
sycl_train_dep_data = sycl_buffer(train_dep_data)
sycl_test_indep_data = sycl_buffer(test_indep_data)
result_cpu, _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data)
# The prediction result provides prediction
assert result_classic.prediction.shape == (test_dep_data.shape[0], test_dep_data.shape[1])
assert np.allclose(result_classic.prediction, result_cpu.prediction)
return (train_result, result_classic, test_dep_data)
if __name__ == "__main__":
(train_result, predict_result, test_dep_data) = main()
print("\nLinear Regression coefficients:\n", train_result.model.Beta)
print("\nLinear Regression prediction results: (first 10 rows):\n", predict_result.prediction[0:10])
print("\nGround truth (first 10 rows):\n", test_dep_data[0:10])
print('All looks good!')
|
#!/usr/bin/python
# Classification (U)
"""Program: gtidset_init.py
Description: Unit testing of GTIDSet.__init__ in mysql_class.py.
Usage:
test/unit/mysql_class/gtidset_init.py
Arguments:
"""
# Libraries and Global Variables
# Standard
import sys
import os
if sys.version_info < (2, 7):
import unittest2 as unittest
else:
import unittest
# Third-party
import mock
# Local
sys.path.append(os.getcwd())
import mysql_class
import version
__version__ = version.__version__
class UnitTest(unittest.TestCase):
"""Class: UnitTest
Description: Class which is a representation of a unit testing.
Methods:
setUp
test_gtidset_basestring
test_gtidset_init
"""
def setUp(self):
"""Function: setUp
Description: Initialization for unit testing.
Arguments:
"""
self.gtidset = "35588520:333217-740055"
self.results = {"35588520": [(333217, 740055)]}
@mock.patch("mysql_class.isinstance", mock.Mock(return_value=False))
def test_gtidset_basestring(self):
"""Function: test_gtidset_basestring
Description: Test with basestring parameter.
Arguments:
"""
gtid = mysql_class.GTIDSet(self.gtidset)
self.assertEqual(gtid.gtids, self.results)
def test_gtidset_init(self):
"""Function: test_gtidset_init
Description: Test GTIDSet.__init__ method.
Arguments:
"""
gtid = mysql_class.GTIDSet(self.gtidset)
self.assertEqual(gtid.gtids, self.results)
if __name__ == "__main__":
unittest.main()
|
from tensorflow.python.keras import activations
from tensorflow.python.keras.utils import tf_utils
import tensorflow as tf
import numpy as np
import numpy as np
import time
import argparse
class subLSTMCell(tf.keras.layers.Layer):
"""Cell class for the subLSTM layer.
Arguments:
units: Positive integer, dimensionality of the output space.
activation: Activation function to use.
recurrent_activation: Activation function to use
for the recurrent step.
Call arguments:
inputs: A 2D tensor.
states: List of state tensors corresponding to the previous timestep.
"""
def __init__(self,
units,
output_size,
**kwargs):
super(subLSTMCell, self).__init__(**kwargs)
self.units = units
self.recurrent_kernel = self.add_weight(
shape=(self.units, self.units * 4),
name='recurrent_kernel')
self.bias = self.add_weight(
shape=(1, self.units * 4),
name='bias')
self.classifer = tf.keras.layers.Dense(output_size)
@tf_utils.shape_type_conversion
def build(self, input_shape):
input_dim = input_shape[-1]
self.kernel = self.add_weight(
shape=(input_dim, self.units * 4),
name='kernel')
def call(self, inputs, states):
h_tm1, c_tm1 = states
x = inputs @ self.kernel + self.bias
h = h_tm1 @ self.recurrent_kernel
i, f, c, o = tf.split(activations.sigmoid(x + h), num_or_size_splits=4, axis=1)
c = f * c_tm1 + c - i
h = activations.sigmoid(c) - o
outputs = self.classifer(h)
return outputs, [h, c]
def test_train_perf(batch_size):
model = subLSTMCell(128, 10)
data = tf.convert_to_tensor(np.random.randn(batch_size, 28 * 28), np.float32)
old_h = tf.convert_to_tensor(np.random.randn(batch_size, 128), np.float32)
old_c = tf.convert_to_tensor(np.random.randn(batch_size, 128), np.float32)
labels = tf.convert_to_tensor(np.random.randn(batch_size, 10), np.float32)
@tf.function(experimental_compile=USE_XLA)
def model_loss(data, states, labels):
logits, _ = model(data, states)
loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)
return loss
model_loss(data, [old_h, old_c], labels)
number = 10
repeats = 10
optimizer = tf.optimizers.SGD(learning_rate=0.002)
for i in range(number):
records = []
for j in range(repeats):
start_time = time.time()
with tf.GradientTape() as tape:
loss = model_loss(data, [old_h, old_c], labels)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
end_time = time.time()
records.append(end_time - start_time)
print("Average training latency {} ms".format(1000. * np.mean(records)))
print("Median training latency {} ms".format(1000. * np.median(records)))
def test_infer_perf(batch_size):
model = subLSTMCell(128, 10)
data = tf.convert_to_tensor(np.random.randn(batch_size, 28 * 28), np.float32)
old_h = tf.convert_to_tensor(np.random.randn(batch_size, 128), np.float32)
old_c = tf.convert_to_tensor(np.random.randn(batch_size, 128), np.float32)
@tf.function(experimental_compile=USE_XLA)
def model_func(data, states):
out = model(data, states)
return out
model_func(data, [old_h, old_c])
number = 10
repeats = 10
for i in range(repeats):
records = []
for j in range(number):
start_time = time.time()
logits, _ = model_func(data, [old_h, old_c])
end_time = time.time()
records.append(end_time - start_time)
print("Average inference latency {} ms".format(1000. * np.mean(records)))
print("Median inference latency {} ms".format(1000. * np.median(records)))
if __name__ == "__main__":
USE_XLA = True
parser = argparse.ArgumentParser()
parser.add_argument("--batch_size", type=int, default=1)
parser.add_argument("--device", type=str, default=0)
parser.add_argument("--train", action="store_true")
args = parser.parse_args()
with tf.device('GPU:'+str(args.device)):
if args.train:
test_train_perf(args.batch_size)
else:
test_infer_perf(args.batch_size)
|
import os
import os.path as osp
import shutil
import sys
from tempfile import mkdtemp
import pytest
sys.path.insert(
0, osp.abspath(osp.join(osp.dirname(osp.abspath(__file__)), "..", ".."))
)
from disk import Disk
class TestDiskConstructor(object):
def setup_method(self):
self.tmpdir = mkdtemp()
def teardown_method(self):
shutil.rmtree(self.tmpdir)
def test_should_place_cursor_at_beginning(self):
filename = osp.join(self.tmpdir, "test.vdk")
p = Disk(filename)
assert p.cursor == 0
def test_should_open_and_read_existing_file(self):
filename = osp.join(self.tmpdir, "test.vdk")
initial_content = "test_existing_file_with_unicode_éé❤"
with open(filename, "wb") as f:
data = initial_content.encode()
data += b"\x00" * (3 * 512 - len(data))
f.write(data)
p = Disk(filename)
content = p.read(3)
assert len(content) == len(data)
assert content == data
|
from .job import Job
class SimgrExploreJob(Job):
def __init__(self, simgr, find=None, avoid=None, step_callback=None, until_callback=None, callback=None):
super().__init__('Simulation manager exploring')
self._simgr = simgr
self._find = find
self._avoid = avoid
self._callback = callback
self._step_callback = step_callback
self._until_callback = until_callback
self._interrupted = False
def _run(self, inst):
"""Run the job. Runs in the worker thread."""
def until_callback(*args, **kwargs):
return self._interrupted or callable(self._until_callback) and self._until_callback(*args, **kwargs)
self._simgr.explore(find=self._find, avoid=self._avoid, step_func=self._step_callback, until=until_callback)
return self._simgr
def finish(self, inst, result):
super().finish(inst, result)
self._callback(result)
def __repr__(self):
return "Exploring %r" % self._simgr
def keyboard_interrupt(self):
"""Called from GUI thread. Worker thread will check self._interrupted periodically and exit the job early if
needed. """
self._interrupted = True
@classmethod
def create(cls, simgr, **kwargs):
def callback(result):
simgr.am_event(src='job_done', job='explore', result=result)
return cls(simgr, callback=callback, **kwargs)
|
import * as instructionSets from '@/scripts/si/instructionSets'
test('Instruction Sets', () => {
const port = { write: jest.fn() }
instructionSets.beep(port)
expect(port.write).toHaveBeenLastCalledWith(Buffer.from([0xff, 0x06]))
instructionSets.card5.getData(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x2, 0xb1, 0x00, 0xb1, 0x00, 0x03])
)
instructionSets.card10.getData0(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x00, 0xe2, 0x09, 0x03])
)
instructionSets.card10.getData1(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x01, 0xe3, 0x09, 0x03])
)
instructionSets.card10.getData4(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x04, 0xe6, 0x09, 0x03])
)
instructionSets.card10.getData5(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x05, 0xe7, 0x09, 0x03])
)
instructionSets.card10.getData6(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x06, 0xe4, 0x09, 0x03])
)
instructionSets.card10.getData7(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x07, 0xe5, 0x09, 0x03])
)
instructionSets.card10.getData8(port)
expect(port.write).toHaveBeenLastCalledWith(
Buffer.from([0xff, 0x02, 0xef, 0x01, 0x08, 0xea, 0x09, 0x03])
)
expect(port.write).toHaveBeenCalledTimes(9)
})
|
import React, {Fragment} from "react";
import { useLazyQuery } from "@apollo/client";
import { SEARCH } from "../graphQL functions";
import Back from "../Components/Back";
import SearchIcon from "../Components/Search";
import Close from "../Components/Close";
import SearchData from "./searchData";
import SearchBox from "./Searchbox";
import SearchSVG from "../SVGs/new-search";
import SVGContainer from "../SVGs/SVGcontainer";
import Placeholder from "../Placeholders/Products";
import { MediaQuery } from "../helper";
import NoResult from "./No Result";
import "./search.css";
const Search = () => {
const [state, setState] = React.useState(true);
const [searchItem, setSearchItem] = React.useState("");
const text = String(searchItem);
const [search, { loading, data }] = useLazyQuery(SEARCH);
const { width } = MediaQuery();
const breakpoint = 280;
let view;
if (data === undefined) {
return (
<div className="search-wrapper ">
<div className="header">
{state ? (
<Fragment>
<div className="object-1">
<Back width={30} height={30} />
</div>
<div className="category2">
<SearchBox
input={searchItem}
setInput={(e) => setSearchItem(e.target.value)}
action={() => search({ variables: { text } })}
/>
<div className="object-4 cart ">
<Close
width={breakpoint < width ? 30 : 20}
height={breakpoint < width ? 30 : 20}
action={() => {
setState(false);
}}
/>
</div>
</div>
</Fragment>
) : (
<Fragment>
<div className="category">
<div className="object-1">
<Back width={30} height={30} />
</div>
<div className="object-2">
<div className="search-text"></div>
</div>
</div>
<div className="category">
<div className="object-4 cart ">
<SearchIcon
width={breakpoint < width ? 30 : 20}
height={breakpoint < width ? 30 : 20}
action={() => {
setState(true);
}}
/>
</div>
</div>
</Fragment>
)}
</div>
<div className="main">
<SVGContainer>
<SearchSVG />
<p className="text-3">Search</p>
</SVGContainer>
</div>
</div>
);
}
if (loading) {
view = <Placeholder />;
}
if (data.search.length === 0) {
view = <NoResult />;
}
if (data.search.length > 0) {
view = <SearchData data={data.search} />;
}
return (
<div className="search-wrapper ">
<div className="header">
{state ? (
<Fragment>
<div className="object-1">
<Back width={30} height={30} />
</div>
<div className="category2">
<SearchBox
input={searchItem}
setInput={(e) => setSearchItem(e.target.value)}
action={() => search({ variables: { text } })}
/>
<div className="object-4 cart ">
<Close
width={breakpoint < width ? 30 : 20}
height={breakpoint < width ? 30 : 20}
action={() => {
setState(false);
}}
/>
</div>
</div>
</Fragment>
) : (
<Fragment>
<div className="category">
<div className="object-1">
<Back width={30} height={30} />
</div>
<div className="object-2">
<div className="search-text"></div>
</div>
</div>
<div className="category">
<div className="object-4 cart ">
<SearchIcon
width={breakpoint < width ? 30 : 20}
height={breakpoint < width ? 30 : 20}
action={() => {
setState(true);
}}
/>
</div>
</div>
</Fragment>
)}
</div>
<div className="main">{view}</div>
</div>
);
};
export default Search;
|
"""Implementation of PPO Algorithm."""
from rllib.algorithms.ppo import PPO
from rllib.util.early_stopping import EarlyStopping
from rllib.util.neural_networks.utilities import stop_learning
from rllib.value_function import NNValueFunction
from .actor_critic_agent import ActorCriticAgent
class PPOAgent(ActorCriticAgent):
"""Implementation of the PPO Agent.
References
----------
Schulman, J., Wolski, F., Dhariwal, P., Radford, A., & Klimov, O. (2017).
Proximal policy optimization algorithms. ArXiv.
"""
def __init__(
self,
epsilon=0.2,
lambda_=0.95,
target_kl=0.005,
eta=0.01,
monte_carlo_target=False,
clamp_value=True,
num_iter=80,
num_rollouts=4,
*args,
**kwargs,
):
super().__init__(
algorithm_=PPO,
epsilon=epsilon,
eta=eta,
monte_carlo_target=monte_carlo_target,
clamp_value=clamp_value,
lambda_=lambda_,
num_iter=num_iter,
num_rollouts=num_rollouts,
*args,
**kwargs,
)
self.target_kl = target_kl
self.early_stopping_algorithm = EarlyStopping(
epsilon=1.5 * target_kl, relative=False
)
def early_stop(self, losses, **kwargs):
"""Early stop the training algorithm."""
kl = kwargs.get("kl_div", kwargs.get("approx_kl_div", self.target_kl))
self.early_stopping_algorithm.update(kl)
if self.early_stopping_algorithm.stop:
stop_learning(self.policy)
self.early_stopping_algorithm.reset()
return False
@classmethod
def default(cls, environment, critic=None, *args, **kwargs):
"""See `AbstractAgent.default'."""
if critic is None:
critic = NNValueFunction.default(environment)
return super().default(environment, critic=critic, *args, **kwargs)
|
import json
import pytest
from bocadillo import API, Media
from bocadillo.media import UnsupportedMediaType
def test_defaults_to_json(api: API):
data = {"message": "hello"}
@api.route("/")
async def index(req, res):
res.media = data
response = api.client.get("/")
assert response.status_code == 200
assert response.headers["content-type"] == Media.JSON
assert response.json() == data
def test_can_specify_media_type_when_creating_the_api_object():
API(media_type=Media.PLAIN_TEXT)
def test_media_type_is_accessible_on_api(api: API):
assert hasattr(api, "media_type")
@pytest.mark.parametrize(
"media_type, expected_text",
[(Media.JSON, json.dumps), (Media.PLAIN_TEXT, str), (Media.HTML, str)],
)
def test_use_builtin_media_handlers(api: API, media_type, expected_text):
api.media_type = media_type
data = {"message": "hello"}
@api.route("/")
async def index(req, res):
res.media = data
response = api.client.get("/")
assert response.status_code == 200
assert response.headers["content-type"] == media_type
assert response.text == expected_text(data)
@pytest.fixture
def foo_type():
return "application/foo"
@pytest.fixture
def handle_foo():
return lambda value: f"FOO: {value}"
def test_add_and_use_custom_media_handler(api: API, foo_type, handle_foo):
api.media_handlers[foo_type] = handle_foo
api.media_type = foo_type
@api.route("/")
async def index(req, res):
res.media = "bar"
response = api.client.get("/")
assert response.status_code == 200
assert response.headers["content-type"] == foo_type
assert response.text == handle_foo("bar")
def test_replace_media_handlers(api: API, foo_type, handle_foo):
api.media_handlers = {foo_type: handle_foo}
api.media_type = foo_type
@api.route("/")
async def index(req, res):
res.media = "bar"
response = api.client.get("/")
assert response.status_code == 200
assert response.headers["content-type"] == foo_type
assert response.text == handle_foo("bar")
def test_if_media_type_not_supported_then_setting_it_raises_error(api: API):
foo_type = "application/foo"
with pytest.raises(UnsupportedMediaType) as ctx:
api.media_type = foo_type
assert foo_type in str(ctx.value)
with pytest.raises(UnsupportedMediaType) as ctx:
API(media_type="application/foo")
assert foo_type in str(ctx.value)
|
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = hashCode;
// http://erlycoder.com/49/javascript-hash-functions-to-convert-string-into-integer-hash-
function hashCode(s) {
var str = String(s);
var hash = 0;
var char;
if (str.trim().length === 0) return hash;
for (var i = 0; i < str.length; i++) {
char = str.charCodeAt(i);
hash = (hash << 5) - hash + char; // Convert to 32bit integer
hash &= hash;
}
return Math.abs(hash);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hdmF0YXIvc3JjL3V0aWxzL2hhc2guanMiXSwibmFtZXMiOlsiaGFzaENvZGUiLCJzIiwic3RyIiwiU3RyaW5nIiwiaGFzaCIsImNoYXIiLCJ0cmltIiwibGVuZ3RoIiwiaSIsImNoYXJDb2RlQXQiLCJNYXRoIiwiYWJzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBQUE7QUFDZSxTQUFTQSxRQUFULENBQWtCQyxDQUFsQixFQUFxQjtBQUNsQyxNQUFNQyxHQUFHLEdBQUdDLE1BQU0sQ0FBQ0YsQ0FBRCxDQUFsQjtBQUNBLE1BQUlHLElBQUksR0FBRyxDQUFYO0FBQ0EsTUFBSUMsSUFBSjtBQUNBLE1BQUlILEdBQUcsQ0FBQ0ksSUFBSixHQUFXQyxNQUFYLEtBQXNCLENBQTFCLEVBQTZCLE9BQU9ILElBQVA7O0FBQzdCLE9BQUssSUFBSUksQ0FBQyxHQUFHLENBQWIsRUFBZ0JBLENBQUMsR0FBR04sR0FBRyxDQUFDSyxNQUF4QixFQUFnQ0MsQ0FBQyxFQUFqQyxFQUFxQztBQUNuQ0gsSUFBQUEsSUFBSSxHQUFHSCxHQUFHLENBQUNPLFVBQUosQ0FBZUQsQ0FBZixDQUFQO0FBQ0FKLElBQUFBLElBQUksR0FBRyxDQUFDQSxJQUFJLElBQUksQ0FBVCxJQUFjQSxJQUFkLEdBQXFCQyxJQUE1QixDQUZtQyxDQUduQzs7QUFDQUQsSUFBQUEsSUFBSSxJQUFJQSxJQUFSO0FBQ0Q7O0FBQ0QsU0FBT00sSUFBSSxDQUFDQyxHQUFMLENBQVNQLElBQVQsQ0FBUDtBQUNEIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cDovL2VybHljb2Rlci5jb20vNDkvamF2YXNjcmlwdC1oYXNoLWZ1bmN0aW9ucy10by1jb252ZXJ0LXN0cmluZy1pbnRvLWludGVnZXItaGFzaC1cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhhc2hDb2RlKHMpIHtcbiAgY29uc3Qgc3RyID0gU3RyaW5nKHMpXG4gIGxldCBoYXNoID0gMFxuICBsZXQgY2hhclxuICBpZiAoc3RyLnRyaW0oKS5sZW5ndGggPT09IDApIHJldHVybiBoYXNoXG4gIGZvciAobGV0IGkgPSAwOyBpIDwgc3RyLmxlbmd0aDsgaSsrKSB7XG4gICAgY2hhciA9IHN0ci5jaGFyQ29kZUF0KGkpXG4gICAgaGFzaCA9IChoYXNoIDw8IDUpIC0gaGFzaCArIGNoYXJcbiAgICAvLyBDb252ZXJ0IHRvIDMyYml0IGludGVnZXJcbiAgICBoYXNoICY9IGhhc2hcbiAgfVxuICByZXR1cm4gTWF0aC5hYnMoaGFzaClcbn1cbiJdfQ== |
// Karma configuration file, see link for more information
// https://karma-runner.github.io/1.0/config/configuration-file.html
module.exports = function(config) {
config.set({
basePath: '',
frameworks: ['jasmine', '@angular-devkit/build-angular'],
plugins: [
require('karma-jasmine'),
require('karma-chrome-launcher'),
require('karma-jasmine-html-reporter'),
require('karma-coverage-istanbul-reporter'),
require('@angular-devkit/build-angular/plugins/karma'),
],
client: {
clearContext: false, // leave Jasmine Spec Runner output visible in browser
},
coverageIstanbulReporter: {
dir: require('path').join(__dirname, './coverage/apsi-enrollment-fe'),
reports: ['html', 'lcovonly', 'text-summary'],
fixWebpackSourcePaths: true,
},
logLevel: config.LOG_DEBUG,
reporters: ['progress', 'kjhtml'],
port: 9876,
colors: true,
logLevel: config.LOG_INFO,
autoWatch: true,
browsers: ['ChromeHeadlessNoSandbox'],
customLaunchers: {
ChromeHeadlessNoSandbox: {
base: 'ChromeHeadless',
flags: ['--no-sandbox']
}
},
singleRun: false,
restartOnFileChange: true,
});
};
|
module.exports = function(grunt) {
grunt.registerTask('deploy', [
'deployOnlyOnStagingOrProd',
'build',
'buildDemo',
'gzip',
'shell:deployS3-docs',
'shell:deployS3-lib',
'shell:deployS3-demo'
]);
grunt.registerTask('deploy-demo', [
'buildDemo',
'shell:deployS3-demo'
]);
grunt.registerTask('deployOnlyOnStagingOrProd', 'Shuts down the process if not on prod or staging', function() {
var env = grunt.option('env');
var isDeployableEnv = ['staging', 'prod'].indexOf(env) !== -1;
if (!isDeployableEnv) {
grunt.fail.fatal('Unable to deploy on env ' + env);
}
});
return grunt.config.merge({
shell: {
'deployS3-lib': {
command: 'aws s3 cp <%=buildDirs.lib %> <%=deployBuckets.lib %> ' +
'--recursive ' +
'--content-encoding gzip ' +
'--cache-control max-age=1800 ' +
'--quiet'
},
'deployS3-docs': {
command: 'aws s3 cp <%=buildDirs.docs %> <%=deployBuckets.docs %> ' +
'--recursive ' +
'--cache-control max-age=1800 ' +
'--quiet'
},
'deployS3-demo': {
command: 'aws s3 cp <%=buildDirs.demo %> <%=deployBuckets.demo %> ' +
'--recursive ' +
'--cache-control max-age=1800 ' +
'--quiet'
}
}
});
};
|
export const tpHours = [
{ key: '00', name: '00' },
{ key: '01', name: '01' },
{ key: '02', name: '02' },
{ key: '03', name: '03' },
{ key: '04', name: '04' },
{ key: '05', name: '05' },
{ key: '06', name: '06' },
{ key: '07', name: '07' },
{ key: '08', name: '08' },
{ key: '09', name: '09' },
{ key: '10', name: '10' },
{ key: '11', name: '11' },
{ key: '12', name: '12' },
{ key: '13', name: '13' },
{ key: '14', name: '14' },
{ key: '15', name: '15' },
{ key: '16', name: '16' },
{ key: '17', name: '17' },
{ key: '18', name: '18' },
{ key: '19', name: '19' },
{ key: '20', name: '20' },
{ key: '21', name: '21' },
{ key: '22', name: '22' },
{ key: '23', name: '23' },
{ key: '24', name: '24' }
];
export const tpMinuts = [
{ key: '00', name: '00' },
{ key: '01', name: '01' },
{ key: '02', name: '02' },
{ key: '03', name: '03' },
{ key: '04', name: '04' },
{ key: '05', name: '05' },
{ key: '06', name: '06' },
{ key: '07', name: '07' },
{ key: '08', name: '08' },
{ key: '09', name: '09' },
{ key: '10', name: '10' },
{ key: '11', name: '11' },
{ key: '12', name: '12' },
{ key: '13', name: '13' },
{ key: '14', name: '14' },
{ key: '15', name: '15' },
{ key: '16', name: '16' },
{ key: '17', name: '17' },
{ key: '18', name: '18' },
{ key: '19', name: '19' },
{ key: '20', name: '20' },
{ key: '21', name: '21' },
{ key: '22', name: '22' },
{ key: '23', name: '23' },
{ key: '24', name: '24' },
{ key: '25', name: '25' },
{ key: '26', name: '26' },
{ key: '27', name: '27' },
{ key: '28', name: '28' },
{ key: '29', name: '29' },
{ key: '30', name: '30' },
{ key: '31', name: '31' },
{ key: '32', name: '32' },
{ key: '33', name: '33' },
{ key: '34', name: '34' },
{ key: '35', name: '35' },
{ key: '36', name: '36' },
{ key: '37', name: '37' },
{ key: '38', name: '38' },
{ key: '39', name: '39' },
{ key: '40', name: '40' },
{ key: '41', name: '41' },
{ key: '42', name: '42' },
{ key: '43', name: '43' },
{ key: '44', name: '44' },
{ key: '45', name: '45' },
{ key: '46', name: '46' },
{ key: '47', name: '47' },
{ key: '48', name: '48' },
{ key: '49', name: '49' },
{ key: '50', name: '50' },
{ key: '51', name: '51' },
{ key: '52', name: '52' },
{ key: '53', name: '53' },
{ key: '54', name: '54' },
{ key: '55', name: '55' },
{ key: '56', name: '56' },
{ key: '57', name: '57' },
{ key: '58', name: '58' },
{ key: '59', name: '59' }
];
|
#!/usr/bin/env python3
#
# Copyright (c) 2016, Neil Booth
#
# All rights reserved.
#
# See the file "LICENCE" for information about the copyright
# and warranty status of this software.
'''Script to send RPC commands to a running ElectrumX server.'''
import argparse
import asyncio
import json
from functools import partial
from os import environ
from lib.jsonrpc import JSONSession, JSONRPCv2
from server.controller import Controller
class RPCClient(JSONSession):
def __init__(self):
super().__init__(version=JSONRPCv2)
self.max_send = 0
self.max_buffer_size = 5*10**6
async def wait_for_response(self):
await self.items_event.wait()
await self.process_pending_items()
def send_rpc_request(self, method, params):
handler = partial(self.handle_response, method)
self.send_request(handler, method, params)
def handle_response(self, method, result, error):
if method in ('groups', 'peers', 'sessions') and not error:
lines_func = getattr(Controller, '{}_text_lines'.format(method))
for line in lines_func(result):
print(line)
elif error:
print('error: {} (code {:d})'
.format(error['message'], error['code']))
else:
print(json.dumps(result, indent=4, sort_keys=True))
def rpc_send_and_wait(port, method, params, timeout=15):
loop = asyncio.get_event_loop()
coro = loop.create_connection(RPCClient, 'localhost', port)
try:
transport, rpc_client = loop.run_until_complete(coro)
rpc_client.send_rpc_request(method, params)
try:
coro = rpc_client.wait_for_response()
loop.run_until_complete(asyncio.wait_for(coro, timeout))
except asyncio.TimeoutError:
print('request timed out after {}s'.format(timeout))
except OSError:
print('cannot connect - is ElectrumX catching up, not running, or '
'is {:d} the wrong RPC port?'.format(port))
finally:
loop.close()
def main():
'''Send the RPC command to the server and print the result.'''
parser = argparse.ArgumentParser('Send electrumx an RPC command')
parser.add_argument('-p', '--port', metavar='port_num', type=int,
help='RPC port number')
parser.add_argument('command', nargs=1, default=[],
help='command to send')
parser.add_argument('param', nargs='*', default=[],
help='params to send')
args = parser.parse_args()
port = args.port
if port is None:
port = int(environ.get('RPC_PORT', 9891))
# Get the RPC request.
method = args.command[0]
params = args.param
if method in ('log', 'disconnect'):
params = [params]
rpc_send_and_wait(port, method, params)
if __name__ == '__main__':
main()
|
# pylint: skip-file
# flake8: noqa
# pylint: skip-file
# pylint: disable=wrong-import-position,wrong-import-order
import base64
# pylint: disable=too-many-arguments
class OCSecret(OpenShiftCLI):
''' Class to wrap the oc command line tools
'''
def __init__(self,
namespace,
secret_name=None,
decode=False,
kubeconfig='/etc/origin/master/admin.kubeconfig',
verbose=False):
''' Constructor for OpenshiftOC '''
super(OCSecret, self).__init__(namespace, kubeconfig=kubeconfig, verbose=verbose)
self.name = secret_name
self.decode = decode
def get(self):
'''return a secret by name '''
results = self._get('secrets', self.name)
results['decoded'] = {}
results['exists'] = False
if results['returncode'] == 0 and results['results'][0]:
results['exists'] = True
if self.decode:
if 'data' in results['results'][0]:
for sname, value in results['results'][0]['data'].items():
results['decoded'][sname] = base64.b64decode(value)
if results['returncode'] != 0 and '"%s" not found' % self.name in results['stderr']:
results['returncode'] = 0
return results
def delete(self):
'''delete a secret by name'''
return self._delete('secrets', self.name)
def create(self, files=None, contents=None):
'''Create a secret '''
if not files:
files = Utils.create_tmp_files_from_contents(contents)
secrets = ["%s=%s" % (sfile['name'], sfile['path']) for sfile in files]
cmd = ['secrets', 'new', self.name]
cmd.extend(secrets)
results = self.openshift_cmd(cmd)
return results
def update(self, files, force=False):
'''run update secret
This receives a list of file names and converts it into a secret.
The secret is then written to disk and passed into the `oc replace` command.
'''
secret = self.prep_secret(files)
if secret['returncode'] != 0:
return secret
sfile_path = '/tmp/%s' % self.name
with open(sfile_path, 'w') as sfd:
sfd.write(json.dumps(secret['results']))
atexit.register(Utils.cleanup, [sfile_path])
return self._replace(sfile_path, force=force)
def prep_secret(self, files=None, contents=None):
''' return what the secret would look like if created
This is accomplished by passing -ojson. This will most likely change in the future
'''
if not files:
files = Utils.create_tmp_files_from_contents(contents)
secrets = ["%s=%s" % (sfile['name'], sfile['path']) for sfile in files]
cmd = ['-ojson', 'secrets', 'new', self.name]
cmd.extend(secrets)
return self.openshift_cmd(cmd, output=True)
@staticmethod
# pylint: disable=too-many-return-statements,too-many-branches
# TODO: This function should be refactored into its individual parts.
def run_ansible(params, check_mode):
'''run the ansible idempotent code'''
ocsecret = OCSecret(params['namespace'],
params['name'],
params['decode'],
kubeconfig=params['kubeconfig'],
verbose=params['debug'])
state = params['state']
api_rval = ocsecret.get()
#####
# Get
#####
if state == 'list':
return {'changed': False, 'results': api_rval, state: 'list'}
if not params['name']:
return {'failed': True,
'msg': 'Please specify a name when state is absent|present.'}
########
# Delete
########
if state == 'absent':
if not Utils.exists(api_rval['results'], params['name']):
return {'changed': False, 'state': 'absent'}
if check_mode:
return {'changed': True, 'msg': 'Would have performed a delete.'}
api_rval = ocsecret.delete()
return {'changed': True, 'results': api_rval, 'state': 'absent'}
if state == 'present':
if params['files']:
files = params['files']
elif params['contents']:
files = Utils.create_tmp_files_from_contents(params['contents'])
else:
return {'failed': True,
'msg': 'Either specify files or contents.'}
########
# Create
########
if not Utils.exists(api_rval['results'], params['name']):
if check_mode:
return {'changed': True,
'msg': 'Would have performed a create.'}
api_rval = ocsecret.create(files, params['contents'])
# Remove files
if files and params['delete_after']:
Utils.cleanup([ftmp['path'] for ftmp in files])
if api_rval['returncode'] != 0:
return {'failed': True,
'msg': api_rval}
return {'changed': True,
'results': api_rval,
'state': 'present'}
########
# Update
########
secret = ocsecret.prep_secret(params['files'], params['contents'])
if secret['returncode'] != 0:
return {'failed': True, 'msg': secret}
if Utils.check_def_equal(secret['results'], api_rval['results'][0]):
# Remove files
if files and params['delete_after']:
Utils.cleanup([ftmp['path'] for ftmp in files])
return {'changed': False,
'results': secret['results'],
'state': 'present'}
if check_mode:
return {'changed': True,
'msg': 'Would have performed an update.'}
api_rval = ocsecret.update(files, force=params['force'])
# Remove files
if secret and params['delete_after']:
Utils.cleanup([ftmp['path'] for ftmp in files])
if api_rval['returncode'] != 0:
return {'failed': True,
'msg': api_rval}
return {'changed': True,
'results': api_rval,
'state': 'present'}
return {'failed': True,
'changed': False,
'msg': 'Unknown state passed. %s' % state,
'state': 'unknown'}
|
import React from "react";
import { NavLink, withRouter } from "react-router-dom";
const Navigation = ({ history }) => {
const signOut = () => {
localStorage.removeItem('token');
history.push('/login');
};
return (
<div className="App">
<nav className="nav">
<div className="title-bar">
<h1>Secret Family Recipes</h1>
</div>
<div className="nav-links">
<a href="https://modest-lumiere-17a08c.netlify.app/" target="_blank">Home</a>
<a href="https://modest-lumiere-17a08c.netlify.app/about" target="_blank">About</a>
<NavLink to="/">Dashboard</NavLink>
<NavLink to="/add-recipe">Add New Recipe</NavLink>
<button onClick={signOut}>Sign Out</button>
</div>
</nav>
</div>
)
}
export default withRouter(Navigation); |
//
// SwiftFP.h
// SwiftFP
//
// Created by Hai Pham on 14/3/18.
// Copyright © 2018 Hai Pham. All rights reserved.
//
#import <UIKit/UIKit.h>
//! Project version number for SwiftFP.
FOUNDATION_EXPORT double SwiftFPVersionNumber;
//! Project version string for SwiftFP.
FOUNDATION_EXPORT const unsigned char SwiftFPVersionString[];
// In this header, you should import all the public headers of your framework using statements like #import <SwiftFP/PublicHeader.h>
|
//=================================================================================================
/*!
// \file blaze/math/constraints/MatGenExpr.h
// \brief Constraint on the data type
//
// Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group nor the names of its contributors
// may be used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
*/
//=================================================================================================
#ifndef _BLAZE_MATH_CONSTRAINTS_MATGENEXPR_H_
#define _BLAZE_MATH_CONSTRAINTS_MATGENEXPR_H_
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <blaze/math/typetraits/IsMatGenExpr.h>
namespace blaze {
//=================================================================================================
//
// MUST_BE_MATGENEXPR_TYPE CONSTRAINT
//
//=================================================================================================
//*************************************************************************************************
/*!\brief Constraint on the data type.
// \ingroup math_constraints
//
// In case the given data type \a T is not a matrix generator expression (i.e. a type derived
// from the MatGenExpr base class), a compilation error is created.
*/
#define BLAZE_CONSTRAINT_MUST_BE_MATGENEXPR_TYPE(T) \
static_assert( ::blaze::IsMatGenExpr_v<T>, "Non-matrix generator expression type detected" )
//*************************************************************************************************
//=================================================================================================
//
// MUST_NOT_BE_MATGENEXPR_TYPE CONSTRAINT
//
//=================================================================================================
//*************************************************************************************************
/*!\brief Constraint on the data type.
// \ingroup math_constraints
//
// In case the given data type \a T is a matrix generator expression (i.e. a type derived from
// the MatGenExpr base class), a compilation error is created.
*/
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATGENEXPR_TYPE(T) \
static_assert( !::blaze::IsMatGenExpr_v<T>, "Matrix generator expression type detected" )
//*************************************************************************************************
} // namespace blaze
#endif
|
NEWSCHEMA('Users/Groups', function(schema) {
schema.define('id', 'String(50)');
schema.define('name', 'String(50)');
schema.define('note', 'String(200)');
schema.define('apps', '[Object]'); // [{ id: UID, roles: [] }]
schema.setQuery(function($) {
if ($.controller && FUNC.notadmin($))
return;
var arr = [];
for (var i = 0; i < MAIN.groups.length; i++) {
var group = MAIN.groups[i];
var obj = {};
obj.id = group.id;
obj.name = group.name;
obj.dtcreated = group.dtcreated;
obj.dtupdated = group.dtupdated;
obj.note = group.note;
obj.apps = [];
for (var j = 0; j < group.apps.length; j++) {
var appid = group.apps[j];
obj.apps.push({ id: appid, roles: group.appsroles[appid] || EMPTYARRAY });
}
arr.push(obj);
}
$.callback(arr);
});
schema.setPatch(function($) {
if ($.controller && FUNC.notadmin($))
return;
var model = $.clean();
var id = model.id || UID();
var insert = false;
var apps = model.apps;
model.id = undefined;
model.apps = undefined;
model.dtupdated = NOW;
var db = DBMS();
$.extend && $.extend(model);
db.upd('tbl_group', model, true).where('id', id).insert(function(doc) {
doc.dtcreated = NOW;
doc.dtupdated = undefined;
doc.id = id;
insert = true;
});
db.query('UPDATE tbl_user SET dtmodified=$1 WHERE groups && $2', [NOW, [id]]);
if (apps) {
if (!insert)
db.remove('tbl_group_app').where('groupid', id);
for (var i = 0; i < apps.length; i++) {
var appmeta = apps[i];
if (appmeta == null || !appmeta.id)
continue;
var appid = appmeta.id;
var app = MAIN.apps.findItem('id', appmeta.id);
if (app)
db.insert('tbl_group_app', { id: id + appid, groupid: id, appid: appid, roles: appmeta.roles });
}
}
db.callback(function() {
FUNC.refreshgroupsroles(function() {
FUNC.refreshmeta($.done(id));
EMIT('groups/' + (insert ? 'create' : 'udpate'), id);
FUNC.log('groups/' + (insert ? 'create' : 'update'), id, model.name, $);
});
});
});
schema.setRemove(function($) {
if ($.controller && FUNC.notadmin($))
return;
var id = $.query.id;
var group = MAIN.groupscache[id];
if (group == null) {
$.error.replace('@', id);
$.invalid('error-users-group');
return;
}
var pgid = PG_ESCAPE(id);
var db = DBMS();
db.remove('tbl_group').query('id=' + pgid);
db.query('UPDATE tbl_user SET dtmodified=NOW, dtupdated=NOW(), groups=array_remove(groups,{0}) WHERE ({0}=ANY(groups))'.format(pgid));
db.callback(function() {
FUNC.log('groups/remove', id, group.name, $);
FUNC.refreshgroupsroles(function() {
FUNC.refreshmeta($.done());
EMIT('groups/remove', id);
});
});
});
}); |
class GtrendsRepository {
constructor() {
this.resultsOut=[];
this.i=0;
}
//loading data
async loadDataFromJsonFiles()
{
const fs = require('fs-extra')
const data = await fs.readFile('data/inputs.json')
const inputs = JSON.parse(data)
return inputs;
//console.log(inputs)
// console.log('Retrieved inputs from json file:' + inputs.length)
}
saveDataToJsonFile(results){
const fout=require('fs-extra');
let timelineData=results.default.timelineData;
let time ;
let formattedtime;
let formattedAxisTime;
let value1;
let value2;
let value3;
let resultJSON={};
for (let prop in timelineData)
{
time=timelineData[prop].time;
formattedtime=timelineData[prop].formattedTime;
formattedAxisTime=timelineData[prop].formattedAxisTime;
value1=timelineData[prop].value[0];
value2=timelineData[prop].value[1];
value3=timelineData[prop].value[2];
resultJSON.time=time;
resultJSON.formattedtime=formattedtime;
resultJSON.formattedAxisTime=formattedAxisTime;
resultJSON.value1=value1;
resultJSON.value2=value2;
resultJSON.value3=value3;
// console.log(JSON.stringify(resultJSON) + this.i);
// this.resultsOut[this.i]=resultJSON;
fout.appendFile("data/outputs.json", JSON.stringify(resultJSON)+",", (err) => {
if (err) {
console.error(err);
return;
}
console.log("record saved");
});
}
// this.i=+1;
}
}
module.exports = new GtrendsRepository(); |
"""
io utilities
"""
#-----------------------------------------------------------------------------
# Copyright (c) ytree development team. All rights reserved.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
import numpy as np
from unyt import \
unyt_array, \
unyt_quantity
from yt.funcs import \
get_pbar
from ytree.utilities.logger import \
fake_pbar
def parse_h5_attr(f, attr):
"""A Python3-safe function for getting hdf5 attributes.
If an attribute is supposed to be a string, this will return it as such.
This was taken from yt.
"""
val = f.attrs.get(attr, None)
if isinstance(val, bytes):
return val.decode('utf8')
else:
return val
def _hdf5_yt_attr(fh, attr, unit_registry=None):
"""
Read an hdf5 attribute. If there exists another attribute
named <attr>_units, use that to assign units and return
as either a unyt_array or unyt_quantity.
"""
val = fh.attrs[attr]
units = ""
ufield = "%s_units" % attr
if ufield in fh.attrs:
units = fh.attrs[ufield]
if isinstance(units, bytes):
units = units.decode("utf")
if units == "dimensionless":
units = ""
if units != "":
if isinstance(val, np.ndarray):
val = unyt_array(val, units, registry=unit_registry)
else:
val = unyt_quantity(val, units, registry=unit_registry)
return val
def _hdf5_yt_array_lite(fh, field):
"""
Read an hdf5 dataset. If that dataset has a "units" attribute,
return that as well, but do not cast as a unyt_array.
"""
units = ""
if "units" in fh[field].attrs:
units = fh[field].attrs["units"]
if units == "dimensionless": units = ""
return (fh[field][()], units)
def f_text_block(f, block_size=4096, file_size=None, sep="\n",
pbar_string=None):
"""
Read lines from a file faster than f.readlines().
"""
start = f.tell()
if file_size is None:
f.seek(0, 2)
file_size = f.tell() - start
f.seek(start)
nblocks = np.ceil(float(file_size) /
block_size).astype(np.int64)
read_size = file_size + start
lbuff = ""
if pbar_string is None:
pbar = fake_pbar()
else:
pbar = get_pbar(pbar_string, file_size)
for ib in range(nblocks):
offset = f.tell()
my_block = min(block_size, read_size-offset)
if my_block <= 0: break
buff = f.read(my_block)
linl = -1
for ih in range(buff.count(sep)):
inl = buff.find(sep, linl+1)
if inl < 0:
lbuff += buff[linl+1:]
continue
else:
line = lbuff + buff[linl+1:inl]
loc = offset - len(lbuff) + linl + 1
lbuff = ""
linl = inl
pbar.update(loc+len(line)-start+1)
yield line, loc
lbuff += buff[linl+1:]
if lbuff:
loc = f.tell() - len(lbuff)
pbar.update(loc+len(lbuff)-start+1)
yield lbuff, loc
pbar.finish()
|
# coding: utf8
from __future__ import unicode_literals
ADJECTIVES = set("""
n-διάστατος µεταφυτρωτικός άβαθος άβαλτος άβαρος άβατος άβαφος άβγαλτος άβιος
άβλαπτος άβλεπτος άβολος άβουλος άβραστος άβρεχτος άβροχος άβυθος άγαμος
άγγιχτος άγδαρτος άγδυτος άγευστος άγιος άγλυκος άγλωσσος άγναθος άγναντος
άγνεστος άγνωμος άγνωρος άγνωστος άγονος άγουρος άγουστος άγραφος άγραφτος
άγρυπνος άδαρτος άδειος άδειπνος άδενδρος άδεντρος άδετος άδηκτος άδηλος
άδιωχτος άδολος άδοξος άδοτος άδουλος άδροσος άδωρος άεθνος άεργος άζευκτος
άζουμος άζυμος άζωστος άηχος άθαφτος άθελος άθεος άθερμος άθηλυς άθικτος
άθλιος άθολος άθραυστος άθρεπτος άθρεφτος άθρησκος άθυμος άκαιρος άκακος
άκαπνος άκαρδος άκαρπος άκαυστος άκαυτος άκεντρος άκεφος άκλαυτος άκλητος
άκλωθος άκλωστος άκομψος άκοσμος άκουρος άκοφτος άκρατος άκριτος άκρος
άκυρος άκωλος άκων άλαδος άλαλος άλεστος άληκτος άληστος άλικος άλιπος άλιωτος
άλλαχτος άλογος άλουστος άλπειος άλυπος άλυτος άμαζος άμαθος άμαχος άμεμπτος
άμεστος άμετρος άμισθος άμισχος άμοιαστος άμοιρος άμορφος άμουσος άμπαλος
άμωμος άνανδρος άνανθος άναντρος άναρθρος άναρχος άναστρος άναυδος άναυλος
άνετος άνευρος άνηβος άνθιμος άνθινος άνθυγρος άνιπτος άνισος άνιφτος άνομβρος
άνοπτος άνοσμος άνοσος άνοστος άνους άντυτος άνυδρος άνωθεν άξαντος άξαφνος
άξεστος άξιος άξυλος άξυστος άοκνος άοπλος άορνος άοσμος άπαικτος άπαιχτος
άπας άπαστος άπαστρος άπατος άπατρις άπαυστος άπαυτος άπαχος άπειρος άπειρος
άπεπτος άπεφθος άπηκτος άπηχτος άπιαστος άπικρος άπιοτος άπιστος άπιωτος
άπλαστος άπλεκτος άπλερος άπλετος άπλεχτος άπληστος άπλυτος άπνοος άπνους
άπολις άπονος άπορος άπους άπραγος άπρακτος άπραχτος άπρεπος άπροικος
άπτερος άπτυχος άπτωτος άπυρος άρατος άραχλος άριος άριστος άρρηκτος άρρην
άρριζος άρρυθμος άρρωστος άρτιος άσαρκος άσβεστος άσβηστος άσεβος άσειστος
άσεμνος άσημος άσηπτος άσιαχτος άσιγμος άσιτος άσκαφος άσκαφτος άσκεπος
άσκεφτος άσκημος άσκοπος άσμιχτος άσοφος άσπαρτος άσπαστος άσπερμος άσπιλος
άσπλαγχνος άσπλαχνος άσπονδος άσπορος άσπρος άσπρωχτος άστατος άστεγος
άστεργος άστικτος άστολος άστοργος άστοχος άστρινος άστριφτος άστρωτος άστυλος
άσφαγος άσφαιρος άσφακτος άσφαλτος άσφαχτος άσφιχτος άσχετος άσχημος άσωστος
άτακτος άταστος άταφος άταχτος άτεγκτος άτεκνος άτεχνος άτηκτος άτιμος άτιτλος
άτοκος άτολμος άτονος άτοπος άτρεμος άτρητος άτριφτος άτριχος άτρυγος άτρυπος
άτρωτος άτσαλος άτσεπος άτυπος άτυχος άυλος άυπνος άφαγος άφαντος άφατος
άφευκτος άφθαρτος άφθαστος άφθιτος άφθονος άφθορος άφιλος άφκιαστος άφλεκτος
άφορος άφορτος άφραγκος άφραγος άφρακτος άφραστος άφραχτος άφρονας άφροντις
άφρυκτος άφρων άφταστος άφτερος άφτιαστος άφτιαχτος άφυλλος άφυλος άφωνος
άχαρις άχαρος άχλωρος άχνουδος άχολος άχορδος άχραντος άχρηστος άχρονος άχροος
άχτιστος άχυμος άχωστος άψαλτος άψαχτος άψητος άψηφος άψιλος άψογος άψυκτος
άωρος άωτος έγγαμος έγγειος έγγραφος έγκαιρος έγκλειστος έγκριτος έγκυος
έγχορδος έγχρωμος έκδηλος έκδοτος έκθαμβος έκθετος έκθυμος έκκεντρος έκκλητος
έκνομος έκπαγλος έκπληκτος έκπτωτος έκρυθμος έκτακτος έκτοπος έκτυπος έκφρων
έλλογος έμβιος έμμεσος έμμετρος έμμηνος έμμισθος έμμονος έμμορφος έμορφος
έμπιστος έμπλεος έμπρακτος έμπυρος έμφοβος έμφορτος έμφρων έμφυλος έμφυτος
έναρθρος έναστρος ένδακρυς ένδικος ένδοξος ένζυμος ένθεος ένθερμος ένθετος
έννομος έννους ένοπλος ένορκος ένοχος ένρινος ένσπερμος ένστικτος ένστολος
ένταστος έντεχνος έντιμος έντοκος έντονος έντρομος έντυπος ένυδρος έξαλλος
έξαφνος έξεργο έξεργος έξηχος έξοχος έξτρα έξυπνος έξω έξωμος έπηλυς έρημος
έρριζος έρρινος έρρυθμος έσχατος έτερος έτοιμος έτυμος έφεδρος έφιππος έφιππος
έχων έωλος ήδιστος ήμερος ήμισυς ήπιος ήρεμος ήσσων ήσυχος ίλεως ίσαλος
ίσιος ίσος ίστωρ ίσχαιμος αΐδιος αέναος αέρινος αέριος αήθης αήττητος αίθριος
αίσιος αβάγιστος αβάδιστος αβάζος αβάπτιστος αβάρετος αβάσιμος αβάσκαντος
αβάστακτος αβάσταχτος αβάτευτος αβάφτιστος αβέβαιος αβέβηλος αβέλτερος αβέρτος
αβίωτος αβαθής αβαθμίδωτος αβαθμολόγητος αβαθούλωτος αβαθύρριζος αβαλσάμωτος
αβανιοκαμένος αβανταδόρικος αβαρής αβαριάτος αβαρικός αβαροσλαβικός
αβασίλευτος αβγοειδής αβγοκομμένος αβγουλάτος αβγουλωτός αβγωμένος αβδέλυκτος
αβεβήλωτος αβεβαίωτος αβελόνιαστος αβερνίκωτος αβιογενετικός αβιομηχάνητος
αβιομηχανοποίητος αβιοτικός αβλάστητος αβλαβέστατος αβλαβής αβλαπτικός αβλεπής
αβλόγητος αβοήθητος αβολιδοσκόπητος αβομβάρδιστος αβορβόρωτος αβοτάνιστος
αβουτύρωτος αβούλευτος αβούλητος αβούλωτος αβούρκωτος αβούρτσιστος αβούτηχτος
αβράδιαστος αβράκωτος αβράχυντος αβρααμικός αβραμιαίος αβροβόστρυχος
αβρόμιστα αβρόμιστος αβρός αβρόφρων αβυθομέτρητος αβυσσαλέος αβυσσοβενθικός
αβυσσώδης αβόλευτος αβόρβορος αβύζαχτος αβύθιστος αγάθας αγάλακτος αγάμητος
αγέλαστος αγέμιστος αγένειος αγέννητος αγένωτος αγέραστος αγέρινος αγέρωχος
αγαθάρχης αγαθήμερος αγαθαρχικός αγαθιάρης αγαθοβιόλης αγαθοδότης αγαθοεργός
αγαθομαρία αγαθομαρούσα αγαθομούνης αγαθοπάροχος αγαθοποιός αγαθοπρεπής
αγαθοπόνηρος αγαθοσύμβουλος αγαθοφανής αγαθοψώλης αγαθούκλας αγαθούλης
αγαθούτσικος αγαθόβιος αγαθόβουλος αγαθόγνωμος αγαθόδωρος αγαθόκλας
αγαθόπουλο αγαθόπουλος αγαθός αγαθότροπος αγαθότυπος αγαθόψυχος αγαθώνυμος
αγαλβάνιστος αγαλμάτινος αγαλματένιος αγαλματώδης αγαλούχητος αγαμογενετικός
αγανός αγαπημένα αγαπησιάρης αγαπητικός αγαπητός αγαρνίριστος αγαστός αγγίνιο
αγγειοανοσοβλαστικός αγγειοαποφρακτικός αγγειοβλαστικός αγγειοβριθής
αγγειογενετικός αγγειογραφικός αγγειοδιασταλτικός αγγειοδραστικός
αγγειολογικός αγγειοπλαστικός αγγειοσπαστικός αγγειοσυσταλτικός
αγγειόσπερμος αγγειώδης αγγελικός αγγελοειδής αγγελοκάμωτος αγγελοκαμωμένος
αγγελομίμητος αγγελοπρόσωπος αγγελοφτιαγμένος αγγελοφτιασμένος αγγελτικός
αγγελόπλοκος αγγελόψυχος αγγελώνυμος αγγιδιώτικος αγγιχτικός αγγιχτός
αγγλικός αγγλομαθής αγγλοσαξονικός αγγλοτραφής αγγλόφερτος αγγλόφιλος
αγγλόφωνος αγδίκιωτος αγειτόνευτος αγελαίος αγελαδένιος αγελαδίσιος αγελαδινός
αγενής αγερικός αγεροχτυπημένος αγερσανιώτικος αγεφύρωτος αγεωγράφητος
αγεώργητος αγιάτρευτος αγιοβασιλιάτικος αγιοδημητριάτικος αγιορείτικος
αγιοτόκος αγιωτικός αγιότοκος αγιώνυμος αγκάθινος αγκαίνιαστος αγκαζέ
αγκαθερός αγκαθοφόρος αγκαθωτός αγκιστροειδής αγκιστρωτός αγκυλωτός
αγκυρωτικός αγκύλος αγλαός αγλωσσοφάγωτος αγλύκαντος αγναντιαστός αγνωσιακός
αγνωστοποίητος αγνός αγνώμων αγνώριστος αγοήτευτος αγονάτιστος αγορίστικος
αγορανομικός αγοραστικός αγοραστός αγοραφοβικός αγοραφοβικός αγουροξυπνημένος
αγουρωπός αγράμματος αγρατζούνιστος αγρατσούνιστος αγρεύσιμος αγριλίσιος
αγριωπός αγριόφωνος αγροίκος αγροβιομηχανικός αγροδίαιτος αγροδιατροφικός
αγρονομικός αγροτοβιομηχανικός αγροτοδιατροφικός αγροτοκτηνοτροφικός
αγυάλιστος αγχέμαχος αγχίνους αγχογόνος αγχολυτικός αγχωτικός αγχώδης
αγωνιστικός αγωνιώδης αγόγγυστος αγύμναστος αγύρευτος αγύριστος αγώγιμος
αδάμαστος αδάνειστος αδάπανος αδάσυντος αδάσωτος αδέκαρος αδέκαστος αδέξιος
αδέσποτος αδέψητος αδήλωτος αδήμευτος αδήριτος αδήωτος αδίδακτος αδίδαχτος
αδίπλωτος αδίστακτος αδίσταχτος αδίχαστος αδίωκτος αδαής αδαμάντινος
αδαμαντοκόσμητος αδαμαντοποίκιλτος αδαμαντοστόλιστος αδαμαντοφόρος
αδαμαντόστικτος αδαμιαίος αδαπάνητος αδασκάλευτος αδασμολόγητος αδείλιαστος
αδειανός αδειούχος αδελέαστος αδελφικός αδελφοκτόνος αδελφός αδεμάτιαστος
αδενοειδής αδενοπαθής αδενώδης αδερφίστικος αδερφικός αδευτέρωτος
αδημιούργητος αδημοσίευτος αδηφάγος αδιάβαστος αδιάβατος αδιάβλητος αδιάβροχος
αδιάδοτος αδιάζευκτος αδιάθετος αδιάκοπος αδιάκριτος αδιάλειπτος αδιάλεχτος
αδιάλυτος αδιάνθιστος αδιάντροπος αδιάπαυστος αδιάπλαστος αδιάπτωτος
αδιάρρηκτος αδιάσειστος αδιάσπαστος αδιάσταλτος αδιάστατος αδιάτρητος
αδιάφθορος αδιάφορος αδιάψευστος αδιέγερτος αδιέξοδος αδιήθητος αδιαίρετος
αδιαβάθμητος αδιαβίβαστος αδιαβατικός αδιαγούμητος αδιαγούμιστος αδιακήρυκτος
αδιακανόνιστος αδιακλάδωτος αδιακρίβωτος αδιακόρευτος αδιακόσμητος αδιακώλυτος
αδιαλόγητος αδιαμέλιστος αδιαμαρτύρητος αδιαμεσολάβητος αδιαμοίραστος
αδιαμόρφωτος αδιανέμητος αδιανόητος αδιαπέραστος αδιαπαιδαγώγητος αδιαπότιστος
αδιασάλευτος αδιασάφητος αδιασαφήνιστος αδιασκέδαστος αδιασκεύαστος
αδιαστρέβλωτος αδιατάρακτος αδιατάραχτος αδιατήρητος αδιατίμητος
αδιατύπωτος αδιαφέντευτος αδιαφήμιστος αδιαφανής αδιαφιλονίκητος
αδιαφόρετος αδιαφύλακτος αδιαφύλαχτος αδιαφώτιστος αδιαχώρητο αδιαχώρητος
αδιεκδίκητος αδιενέργητος αδιερεύνητος αδιευθέτητος αδιευκρίνητος
αδικαίωτος αδικαιολόγητος αδικομοιρασμένος αδικοπονεμένος αδικοσταυρωμένος
αδιοίκητος αδιοργάνωτος αδιπικός αδιπλασίαστος αδιχοτόμητος αδιόγκωτος
αδιόρθωτος αδιόριστος αδιύλιστος αδογμάτιστος αδοκίμαστος αδολίευτος
αδούλωτος αδρανής αδρανειακός αδρανοβαρυτικός αδρανογόνος αδρασκέλιστος
αδροδάκτυλος αδρομεγέθης αδρομερής αδρόμισθος αδρός αδρόσιστος αδυνάστευτος
αδυνατούτσικος αδυσώπητος αδωροδόκητος αδόκητος αδόκιμος αδόλεσχος αδόλωτος
αδόξαστος αδύναμος αδύνατος αδώρητος αείμνηστος αείφυλλος αειθαλής αεικίνητος
αειφανής αειφόρος αεράτος αεραγηματικός αεραθλητικός αεραποβατικός αερεπίγειος
αεριοφόρος αεριούχος αεριτζίδικος αεριώδης αεροΰφαντος αεροβάμων αεροδίνητος
αεροδρομικός αεροδυναμικός αεροκίνητος αερολιθικός αερολιμενικός αερολόγος
αεροναυτικός αεροναυτιλιακός αεροναυτιλλόμενος αεροπλανικό αεροπλανικός
αεροπορικός αεροστατικός αεροστεγής αεροφόρος αεροχτυπημένος αερόβιος
αερόψυκτος αερώδης αετίσιος αετομάτης αετόμορφος αζάρωτος αζέρικος αζέσταγος
αζήλευτος αζήμιος αζήτητος αζαχάρωτος αζεμάτιστος αζερικός αζερμπαϊτζανικός
αζευγάρωτος αζημίωτος αζιμουθιακός αζωγράφητος αζωγράφιστος αζωικός
αζωτούχος αζύγιαστος αζύγιστος αζύγωτος αζύμωτος αηδής αηδιαστικός
αηδονόλαλος αηδονόστομος αηδονόφωνος αθάμβωτος αθάμπωτος αθάνατος αθάρρευτος
αθέλητος αθέμιτος αθέριστος αθέρμαντος αθέσπιστος αθήλαστος αθήλιαστος αθαμβής
αθειάφιστος αθεμέλιωτος αθεμελίωτος αθεολόγητος αθεράπευτος αθεσμοθέτητος
αθεϊστικός αθεόφοβος αθεώρητος αθηλύκωτος αθημώνιαστος αθηναίικος
αθηναϊκός αθησαύριστος αθλητιατρικός αθλητικός αθλομανής αθλοφόρος αθορύβητος
αθροιστικός αθρυμμάτιστος αθρόος αθυμιάτιστος αθυρόστομος αθωνικός αθωράκιστος
αθωότης αθόλωτος αθόρυβος αθύμωτος αθώος αθώπευτος αθώρητος αιγαίος αιγαιακός
αιγαλιώτικος αιγιακός αιγιαλίτης αιγινήτικος αιγοπρόβειος αιγυπτιακός
αιδήμων αιθέριος αιθαλώδης αιθερικός αιθεριώδης αιθεροβάμων αιθουσονωτιαίος
αιθυλιούχος αιλουροειδής αιμάτινος αιματηρός αιματικός αιματοβούτηχτος
αιματολογικός αιματοπότιστος αιματόβρεκτος αιματόβρεχτος αιματόχροος
αιματώδης αιμοβόρικος αιμοβόρος αιμοδιψής αιμοδυναμικός αιμολυτικός
αιμομικτικός αιμορραγικός αιμορροφιλικός αιμορροϊκός αιμοσταγής αιμοστατικός
αιμοφόρος αιμοχαρής αιμοχρωστικός αιμόφιλος αιμόφυρτος αινέσιμος αινετός
αινιγματώδης αιολικός αιρετός αισθαντικός αισθηματικός αισθησιακός
αισθησιοκρατικός αισθητήριος αισθητηριακός αισθητικοκινητικός αισθητικός
αισιόδοξος αισχροκερδής αισχρολογικός αισχρολόγος αισχρός αισχυλικός
αισχύλειος αισωπικός αισώπειος αιτητικός αιτιάσιμος αιτιακός αιτιατικός
αιτιοκρατικός αιτιολογικός αιτιοπαθογενετικός αιτιώδης αιτωλικός αιφνίδιος
αιχμάλωτος αιχμηρός αιωνόβιος αιώνιος ακάθαρτος ακάθεκτος ακάθιστος ακάλεστος
ακάματος ακάμωτος ακάνθινος ακάπνιστος ακάρπιστος ακάρφωτος ακάτεχος ακάτιος
ακένωτος ακέραιος ακέραστος ακέριος ακέρωτος ακέφαλος ακήδευτος ακήρατος
ακήρυχτος ακίβδηλος ακίνδυνος ακίνητος ακαής ακαβάλητος ακαβούρδιστος
ακαδημαϊκός ακαθάριστος ακαθίδρυτος ακαθιέρωτος ακαθοδήγητος ακαθόριστος
ακακολόγητος ακαλίγωτος ακαλαίσθητος ακαλαφάτιστος ακαλλιέργητος ακαλλώπιστος
ακαλοκάρδιστος ακαμάκιαστος ακαμάκιστος ακαμάκωτος ακαμάτης ακαμίνευτος
ακανθοκυτταρικός ακανθοστεφής ακανθώδης ακανόνιστος ακαπάκωτος ακαπάρωτος
ακαπήλευτος ακαπίστρωτος ακαπλάντιστος ακαρίκωτος ακαρατόμητος ακαριαίος
ακαρποφόρητος ακαρύκευτος ακασσιτέρωτος ακατάβρεκτος ακατάβρεχτος ακατάγγελτος
ακατάδεχτος ακατάκτητος ακατάληκτος ακατάληπτος ακατάλληλος ακατάλυτος
ακατάπαυτος ακατάρτιστος ακατάσβεστος ακατάσβηστος ακατάστατος ακατάσχετος
ακατάταχτος ακατάφερτος ακατέβατος ακατέργαστος ακατήχητος ακαταίσχυντος
ακαταγώνιστος ακαταδίωκτος ακατακρήμνιστος ακατακύρωτος ακαταλαβίστικος
ακαταλόγιστος ακαταμάχητος ακαταμέτρητος ακατανάλωτος ακατανίκητος ακατανόητος
ακαταπολέμητος ακαταπόνητος ακατασίγαστος ακατασκεύαστος ακαταστάλακτος
ακατατόπιστος ακαταφρόνετος ακαταφρόνητος ακαταχώνιαστος ακαταχώρητος
ακατεδάφιστος ακατεύθυντος ακατεύναστος ακατηγόρητος ακατοίκητος ακατονόμαστος
ακατράμωτος ακατόρθωτος ακαυτηρίαστος ακαψάλιστος ακερδής ακερικός ακηδής
ακηλίδωτος ακιδωτός ακλάδευτος ακλήρωτος ακλήτευτος ακλεής ακλείδωτος
ακλυδώνιστος ακλόνητος ακμάζων ακμαίος ακοίμητος ακοίταχτος ακοιλωματικός
ακοινοποίητος ακοινώνητος ακολλάριστος ακολουθιακός ακολύμπητος ακομμάτιαστος
ακονιστικός ακοομετρικός ακοπάνιστος ακορνίζωτος ακορνιζάριστος ακοροΐδευτος
ακορύφωτος ακοσκίνιστος ακοστολόγητος ακουβάλητος ακουστικός ακουστός
ακουόμετρο ακούμπωτος ακούνητος ακούραστος ακούρδιστος ακούρευτος ακούρντιστος
ακούσιος ακράδαντος ακράτητος ακρήμνιστος ακραίος ακραιφνής ακρατής ακριανός
ακριβοδίκαιος ακριβοθώρητος ακριβολόγος ακριβομίλητος ακριβούτσικος ακριβός
ακριδοκτόνος ακριμάτιστος ακρινός ακριτικός ακριτόμυθος ακροαματικός
ακροαστικός ακροβατικός ακρογωνιαίος ακροδεξιός ακροθιγής ακροκεντρικός
ακροτελεύτιος ακροφωνικός ακρυλικός ακρυστάλλωτος ακρωμιοκλειδικός ακρόλιθος
ακτέριστος ακτήμονας ακτήμων ακταίος ακτιβιστικός ακτινοβόλος ακτινογραφικός
ακτινοθεραπευτικός ακτινολογικός ακτινομετρικός ακτινοσκοπικός ακτινοστόλιστος
ακτινωτός ακτινώδης ακτοπλοϊκός ακτουάριος ακτύπητος ακυβέρνητος ακυκλοφόρητος
ακυρίευτος ακυρωτικός ακυρώσιμος ακυτταρικός ακωδικοποίητος ακωμώδητος
ακόλλητος ακόλουθος ακόμιστος ακόνιστος ακόρδωτος ακόρεστος ακόρυφος ακόσμητος
ακύρωτος ακώλυτος αλάβωτος αλάδωτος αλάθευτος αλάθητος αλάλητος αλάνθαστος
αλάξευτος αλάργος αλέγρος αλέκιαστος αλέρωτος αλήστευτος αλήτικος αλίμενος
αλίπαστος αλίχνιστος αλαβάστρινος αλαγάριστος αλαζονικός αλαμπής
αλανιάρικος αλαργινός αλαργοτάξιδος αλατερός αλατοφόρος αλατούχος αλατόμητος
αλαφροΐσκιωτος αλαφροκάνταρος αλαφρόμυαλος αλαφρός αλαφρύς αλαφυραγώγητος
αλβανοσοβιετικός αλβανόφωνος αλγαισθητικό αλγαισθητικός αλγεβρικός αλγεινός
αλγογόνος αλγοριθμικός αλείαντος αλεηλάτητος αλειτούργητος αλεκτικός αλεξήνεμο
αλεξίπυρος αλεξίσφαιρος αλεξανδρινός αλεπουδίσιος αλεπτολόγητος αλεστικός
αλευρίτικος αλευροβιομηχανικός αλευροειδής αλευρούχος αλευρωμένος αλευρώδης
αλεύκαντος αλεύκαστος αλεύρινος αληθής αληθινός αληθοφανέστερος αληθοφανής
αλησμόνητος αλιάνιστος αλιβάνιστος αλιγούρευτος αλιευτικός αλιμάριστος
αλιχούδευτος αλκαλικός αλκαϊκός αλκοολικός αλκοολομετρικός αλκοολούχος
αλλαντικός αλλαξόπιστος αλλεπάλληλος αλλεργικός αλλεργιογόνος αλλεργιολογικός
αλληλέγγυος αλληλένδετος αλληλεπιδραστικός αλληλοβοηθητικός αλληλοδιάδοχος
αλληλοεξοντωτικός αλληλοεπηρεαζόμενος αλληλοεπιδρώμενος αλληλοκεντρικός
αλληλοπαθής αλληλόφιλος αλληλόχρεος αλλιώτικος αλλογενής αλλοδαπός αλλοεθνής
αλλοιωτικός αλλοιώσιμος αλλομετρικός αλλοπαθητικός αλλοπαρμένος αλλοπρόσαλλος
αλλοστερικός αλλοτινός αλλοτριοφάγος αλλοτριοφαγικός αλλοχωριανός αλλόγλωσσος
αλλόεθνος αλλόθρησκος αλλόκοτος αλλόπιστος αλλότριος αλλότροπος αλλόφρων
αλλόφωνος αλματώδης αλμυρούτσικος αλμυρός αλογάριαστος αλογήσιος αλογίσιος
αλογόκριτος αλουλούδιαστος αλουλούδιστος αλουμινένιος αλουστράριστος αλούτερος
αλπικός αλπινικός αλσατικός αλσώδης αλταζιμουθιακός αλτικός αλτρουιστικός
αλυσιτελής αλυσοδέσμιος αλυσοειδής αλυσωτός αλυσόδετος αλυτρωτικός αλφαβητικός
αλφαριθμητικός αλφικός αλχημικός αλχημιστικός αλωνάρης αλωνιάτης αλωνιστικός
αλόγιαστος αλόγιστος αλύγιστος αλύπητος αλύτρωτος αλώβητος αλώσιμος αμάγευτος
αμάζευτος αμάθευτος αμάθητος αμάλαγος αμάλαχτος αμάλλιαγος αμάλλιαστος
αμάντευτος αμάντριστος αμάντρωτος αμάραντος αμάρτυρος αμάσητος αμάτιαστος
αμάχητος αμέθοδος αμέθυστος αμέριμνος αμέριστος αμέρωτος αμέστωτος αμέταλλος
αμέτρητος αμήνυτος αμήχανος αμίαντος αμίλητος αμίμητος αμίσθωτος αμαγάριστος
αμαζονικός αμαζόνειος αμαζόνιος αμαθής αμαθημάτιστος αμακιγιάριστος
αμαλγαμωτικός αμανίκωτος αμαντάλωτος αμαντάριστος αμαξιτός αμαξωτός
αμαρκάριστος αμαρτωλός αμαρτύρητος αμασκάρευτος αμαστίγωτος αμαυρός
αμαύριστος αμβληχρός αμβλυγώνιος αμβλυκόρυφος αμβλυντικός αμβλυωπικός
αμβλύς αμβλύστομος αμείλικτος αμείλιχτος αμείωτος αμεθόδευτος αμειδίαστος
αμελής αμελητέος αμερικάνικος αμερικανικός αμερικανοκίνητος
αμερικανόφιλος αμερόληπτος αμεσίτευτος αμετάβατος αμετάβλητος αμετάγγιστος
αμετάθετος αμετάκλητος αμετάλαβος αμετάλλακτος αμετάλλαχτος αμετάπειστος
αμετάπτωτος αμετάτρεπτος αμετάφερτος αμετάφραστος αμεταβίβαστος
αμεταγύριστος αμετακίνητος αμεταμέλητος αμεταμφίεστος αμεταμόρφωτος
αμετανόητος αμεταποίητος αμετασχημάτιστος αμετατόπιστος αμεταχείριστος
αμετροεπής αμιάντινος αμιγής αμικροβιακός αμινοβουτυρικός αμισθοδότητος
αμλετικός αμμοκίτρινος αμμοστρωμένος αμμουδερός αμμωνιακός αμμωνιούχος αμμώδης
αμνήμων αμνήστευτος αμνημόνευτος αμνησίκακος αμνησιακός αμνηστεύσιμος αμνιακός
αμοιβαίος αμοιρολόγητος αμολόγητος αμοντάριστος αμοραλιστικός αμορφοποίητος
αμούστακος αμπάδι αμπάδικος αμπάλωτος αμπελικός αμπελοοινικός αμπελουργικός
αμπερομετρικός αμπογιάντιστος αμπογιάτιστος αμπόλιαστος αμυγδαλάτος
αμυδρός αμυλούχος αμυλώδης αμυντικοβιομηχανικός αμυντικός αμφίαλος αμφίβιος
αμφίβραχυς αμφίδρομος αμφίθυμος αμφίκοιλος αμφίκυρτος αμφίλογος αμφίπλευρος
αμφίσημος αμφίστομος αμφιβαρής αμφιβληστροειδής αμφιβραχικός αμφιγραφικός
αμφιθαλής αμφιθεατρικός αμφιθυμικός αμφικλινής αμφικοιλιακός αμφικτιονικός
αμφιμονοσήμαντος αμφινευστικός αμφιπαθητικός αμφιπρόστυλος αμφιρρεπής
αμφιφανής αμφιφυλικός αμφιφυλόφιλος αμφοτερικός αμφοτεροβαρής αμωλώπιστος
αμόλυβδος αμόλυντος αμόνοιαστος αμόρφωτος αμύητος αμύθητος αμύριστος αμύρωτος
αμώμητος ανάβαθος ανάβροχος ανάγιαστο ανάγλυφος ανάδελφος ανάδρομος ανάερος
ανάκατος ανάκουστος ανάλαδος ανάλατος ανάλαφρος ανάλγητος ανάλεστος ανάλλαγος
ανάλλαχτος ανάλογος ανάμεικτος ανάμειχτος ανάμελος ανάμερος ανάμικτος
ανάνθιστος ανάντης ανάξιος ανάπηρος ανάπλεκος ανάπλωρος ανάποδος ανάπρυμνος
ανάπρωρος ανάριθμος ανάριος ανάριχτος ανάρμεγος ανάρμεχτος ανάρμοστος
ανάρριχτος ανάσκελος ανάσκητος ανάστατος ανάστερος ανάστροφος ανάφεγγος
ανέγγυος ανέγκλητος ανέγνοιαστος ανέγνωμος ανέγνωρος ανέκδοτος ανέκκλητος
ανέλεγκτος ανέλπιδος ανέλπιστος ανέμελος ανέμπειρος ανέμπνευστος ανέμυαλος
ανέντακτος ανένταχτος ανέντιμος ανέξοδος ανέπαγος ανέπαφος ανέραστος ανέρωτος
ανέσπλαγχνος ανέσπλαχνος ανέστιος ανέτοιμος ανέφελος ανέφικτος ανήθικος
ανήκουστος ανήλεος ανήλιαγος ανήλιαστος ανήλικος ανήλιος ανήμερος ανήμπορος
ανήστευτος ανήσυχος ανίατος ανίδεος ανίδρωτος ανίδωτος ανίερος ανίκανος
ανίσκιος ανίσκιωτος ανίσχυρος αναίμακτος αναίμαχτος αναίρετος αναίσθητος
αναίτιος αναβαθμίσιμος αναβλητικός αναβολικός αναβράζων αναβραστός
αναγεννησιακός αναγεννητικός αναγερτός αναγκαίος αναγκαστικός αναγλυφικός
αναγνωριστικός αναγνωστικός αναγνώσιμος αναγομωμένος αναγουλιαστικός
αναγωγισμός αναγωγιστικός αναγώγιμος αναδασωτέος αναδεκτός αναδεχτός
αναδιανεμητικός αναδρομικός αναερόβιος αναζητήσιμος αναζωογονητικός
αναθεωρητικός αναθηματικός αναιδής αναιμικός αναιρέσιμος αναιρετέος
αναιρετικός αναισθησιολογικός αναισθητικός αναιτιολόγητος ανακαινιστικός
ανακατωσούρης ανακατωτός ανακεφαλαιωτικός ανακλαδιστός ανακλαστικός
ανακλητικός ανακλητός ανακοινώσιμος ανακουφιστικός ανακρεόντειος ανακριβής
ανακτορικός ανακόλουθος ανακύψιμος αναλγητικός αναληθής αναλημματικός
αναληπτικός αναλλοίωτος αναλογικός αναλογιστικός αναλυτικός αναλυτικότερος
αναλφάβητος αναλφαβητικός αναλύσιμος αναλώσιμος αναμαλλιάρης αναμνηστικός
αναμπάρωτος αναμφίβολος αναμφίλεκτος αναμφίσημος αναμφισβήτητος ανανεωμένος
ανανεώσιμος ανανθής ανανούριστος αναντίλεκτος αναντίρρητος αναντίστρεπτος
ανανταπόδεικτος ανανταπόδοτος αναντικατάστατος αναντιπροσώπευτος
αναξιοπαθής αναξιοπαθών αναξιοποίητος αναξιοπρεπής αναξιόλογος αναξιόπιστος
αναπάντεχος αναπάντητος αναπαιστικός αναπαλλοτρίωτος αναπαραγωγικός
αναπασχόλητος αναπαυτικός αναπεπταμένος αναπηρικός αναπλαστικός
αναπνευστικός αναποδιάρης αναποδιασμένος αναποζημίωτος αναποκατάστατος
αναπολόγητος αναποτελεσματικός αναποφάσιστος αναποχώριστος αναπροσαρμοζόμενος
αναπόγραφος αναπόδεικτος αναπόδειχτος αναπόδοτος αναπόδραστος αναπόσπαστος
αναπόφευγος αναπόφευκτος αναρίθμητος αναριχτός αναρμάτωτος αναρμόδιος
αναρριχτός αναρροφητικός αναρρωτικός αναρτητέος αναρχικός αναρχοαυτόνομος
ανασκαφικός ανασκευαστικός ανασκοπικός αναστάσιμος ανασταλτικός ανασταλτός
αναστεναμένος αναστηλωτικός αναστρέψιμος ανασυνδυασµένος ανασυρτός
ανασφαλής ανασχετικός ανατάσιμος αναταρασσόμενος ανατιμητικός ανατολίτικος
ανατομικός ανατρέψιμος ανατρεπτικός ανατριχιαστικός ανατροφοδοτικός
αναφαίρετος αναφλέξιμος αναφλεκτικός αναφομοίωτος αναφορικός αναφρόδιτος
αναχρονιστικός αναύλωτος αναύξητος ανδρείος ανδρειωμένος ανδρικός
ανδρολογικός ανδρομόνοικος ανδροπρεπής ανδρωνυμικός ανδρόγυνος ανδρώδης
ανείδωτος ανείπωτος ανείσπρακτος ανείσπραχτος ανεβάσταγος ανεβατός ανεγγύητος
ανεγκρατής ανεγχείρητος ανεγχείριστος ανεδαφικός ανειδίκευτος ανειδοποίητος
ανειλημμένος ανειλικρινής ανειρήνευτος ανεκδήλωτος ανεκδίκαστος ανεκδίκητος
ανεκδοτικός ανεκδοτολογικός ανεκκαθάριστος ανεκλάλητος ανεκμετάλλευτος
ανεκπαίδευτος ανεκπλήρωτος ανεκποίητος ανεκτέλεστος ανεκτίμητος ανεκτικός
ανεκχώρητος ανελέητος ανελαστικός ανελεήμων ανελεύθερος ανελικτικός
ανελλιπής ανεμογραφικός ανεμοδεικτικός ανεμομετρικός ανεμπόδιστος ανεμόδαρτος
ανενεργός ανενημέρωτος ανενθρόνιστος ανενόχλητος ανεξάλειπτος ανεξάντλητος
ανεξέλεγκτος ανεξέλικτος ανεξέταστος ανεξήγητος ανεξίθρησκος ανεξίκακος
ανεξαίρετος ανεξακρίβωτος ανεξαργύρωτος ανεξερεύνητος ανεξεταστέος ανεξιλέωτος
ανεξοικείωτος ανεξόφλητος ανεξύμνητος ανεξύπνητος ανεπάγγελτος ανεπάντεχος
ανεπίγραφος ανεπίδεκτος ανεπίδεχτος ανεπίδοτος ανεπίκαιρος ανεπίκλητος
ανεπίλυτος ανεπίσημος ανεπίστρεπτος ανεπίστροφος ανεπίτευκτος ανεπίτρεπτος
ανεπαίσχυντος ανεπανάληπτος ανεπανόρθωτος ανεπαρκής ανεπαχθής ανεπεξέργαστος
ανεπιβεβαίωτος ανεπιεικής ανεπιθύμητος ανεπικερδής ανεπικύρωτος ανεπιμέλητος
ανεπιτήδειος ανεπιτήδευτος ανεπιτήρητος ανεπιτυχής ανεπιφύλακτος ανεπούλωτος
ανεπρόκοφτος ανεπτυγμένος ανερέθιστος ανερεύνητος ανερμάτιστος ανερμήνευτος
ανερώτευτος ανεσταλμένος ανετοίμαστος ανετυμολόγητος ανευθύγραμμος ανευλαβής
ανευρυσματικός ανευρυσματώδης ανευφάνταστος ανευχαρίστητος ανεφάρμοστος
ανεχτίμητος ανεχτικός ανεχτός ανεχόρταγος ανεόρταστος ανεύθυνος ανεύρετος
ανεύφλεκτος ανηγμένος ανηλεής ανημέρευτος ανημέρωτος ανημέτερος ανηολόγητος
ανησυχητικός ανηφορικός ανθεκτικός ανθελληνικός ανθελονοσιακός ανθενωτικός
ανθιδρωτικός ανθικός ανθισμένος ανθοκομικός ανθοστόλιστος ανθοφόρος ανθρακικός
ανθρακοφόρος ανθρακούχος ανθρακώδης ανθρωπινός ανθρωπιστικός ανθρωπογενής
ανθρωποκεντρικός ανθρωποκτόνος ανθρωπολογικός ανθρωπομετρικός ανθρωπομορφικός
ανθρωποφάγος ανθρωπωνυμικός ανθρωπόμορφος ανθρωπόφιλος ανθρώπειος ανθρώπινος
ανθυποβρυχιακός ανθυψίφωνος ανθόσπαρτος ανθόστρωτος ανθώδης ανιαρός
ανιθυφαλλικός ανικανοποίητος ανικτερικός ανιμιστικός ανιοβόλος ανιονικός
ανισομήκης ανισομεγέθης ανισομερής ανισομετρικός ανισοσκελής ανισοσύλλαβος
ανιστόρητος ανισόβαρος ανισόμερος ανισόπεδος ανισόπλευρος ανισόρροπος
ανιχνευτικός ανιχνεύσιμος ανιών ανοίκειος ανοίκιαστος ανοδικός
ανοικοδομητικός ανοικοδομικός ανοικοδόμητος ανοικοκύρευτος ανοικονόμητος
ανοικτός ανοιξιάτικος ανοιχτομάτης ανοιχτοχέρης ανοιχτοχέρικος ανοιχτόκαρδος
ανοιχτόχερος ανοιχτόχρωμος ανολοκλήρωτος ανομοιογενής ανομοιοκατάληκτος
ανομοιωτικός ανομοιόμορφος ανομολόγητος ανονείρευτος ανοξείδωτος ανοργάνωτος
ανορθολογικός ανορθολογιστικός ανορθωτικός ανορθόγραφος ανορθόδοξος ανοσιακός
ανοσοθεραπευτικός ανοσοκατασταλτικός ανοσοκατεσταλμένος ανοσολογικός
ανοσορυθμιστικός ανοσοτροποποιητικός ανοσοφαρμακολογικός ανοσοϊστοχημικός
ανοχύρωτος ανοϊκός ανούσιος αντάξιος αντάρτικος αντήλιος αντίδικος αντίζηλος
αντίθετος αντίθρησκος αντίμαχος αντίξοος αντίπαλος αντίπερα αντίρροπος
αντίστροφος αντίφα αντίχριστος αντίψυχος ανταγωνιστικός ανταλλάξιμος
αντανακλαστικός ανταπεργιακός ανταποδοτικός ανταποκρίσιμος ανταποκριτικός
ανταρτικός ανταρτοπολεμικός ανταρτόπληκτος αντασφαλιστικός αντεθνικός
αντεκπαιδευτικός αντεμετικός αντενεργών αντεπαναστατικός αντεπιστέλλων
αντεργατικός αντεργκράουντ αντηχητικός αντηχών αντιαγνωστικός αντιαγροτικός
αντιαθλητικός αντιαιμορραγικός αντιαισθητικός αντιαλγικός αντιαλκοολικός
αντιαμερικανικός αντιαναπτυξιακός αντιανεμικός αντιανταρτικός
αντιαρθριτικός αντιαρματικός αντιασφυξιογόνος αντιατομικός αντιατομιστικός
αντιαφροδισιακός αντιβαλκανικός αντιβασιλικός αντιβενιζελικός αντιβεντετικός
αντιβιοτικό αντιβιοτικός αντιβλεννορροιακός αντιγαμητικός αντιγλυκαιμικός
αντιγονορροϊκός αντιγραφικός αντιγριπικός αντιδάνειος αντιδανειακός αντιδεξιός
αντιδημοτικός αντιδιαβητικός αντιδιαμετρικός αντιδικτατορικός αντιδιουρητικός
αντιδιφθεριτικός αντιδογματικός αντιδραστικός αντιδυναστικός αντιεθνικός
αντιεκπαιδευτικός αντιεκρηκτικός αντιεμετικός αντιεμπορευματικός αντιεμπορικός
αντιεπιστημονικός αντιευρωπαϊκός αντιεφιδρωτικός αντιηλιακός αντιηρωικός
αντιθεατρικός αντιθερμαντικός αντιθετικός αντιθρησκευτικός αντιθρομβωτικός
αντιιδρωτικός αντιιικός αντιικός αντιισταμινικός αντικαθεστωτικός
αντικανονικός αντικανονιστικός αντικαπνιστικός αντικαρκινικός
αντικαταναλωτικός αντικατασκοπευτικός αντικατασκοπικός αντικαταστάσιμος
αντικαταστατός αντικειμενικοποιημένος αντικειμενικός αντικειμενοποιημένος
αντικληρικός αντικοινοβουλευτικός αντικοινωνικός αντικομματικός
αντικομουνιστικός αντικομφορμιστικός αντικουνουπικός αντικραδασμικός
αντικριστός αντικρουόμενος αντικυβερνητικός αντικυκλικός αντικυκλωνικός
αντιλαϊκός αντιλεκτικός αντιληπτικός αντιληπτός αντιλογιστικός αντιλυρικός
αντιμέτωπος αντιμαχόμενος αντιμεθυστικός αντιμελοδραματικός αντιμεταθετικός
αντιμεταφυσικός αντιμετωπίσιμος αντιμηνιγγιτικός αντιμικροβιακός
αντιμιλιταριστικός αντιμνημονιακός αντιμοναρχικός αντιμονιούχος
αντιμυκητιασικός αντινεοπλασματικός αντινευρικός αντινεφικός αντινομικός
αντιοικονομικός αντιολισθητικός αντιοξειδωτικός αντιοφικός αντιπαθέστερος
αντιπαθητικός αντιπαιδαγωγικός αντιπανωλικός αντιπαραγωγικός αντιπαραθετικός
αντιπαρασιτικός αντιπαρατάξιμος αντιπατριωτικός αντιπειθαρχικός
αντιπερισπαστικός αντιπηκτικός αντιπιτυριδικός αντιπληθωρικός
αντιπλημμυρικός αντιπνευματικός αντιπνευμονικός αντιποιητικός αντιπολεμικός
αντιπολιτευτικός αντιπολιτικός αντιπροεδρικός αντιπροστατευτικός
αντιπροσωπεύων αντιπροχθεσινός αντιπροχτεσινός αντιπυραυλικός αντιπυρετικό
αντιπυρηνικός αντιπυρικός αντιρατσιστικός αντιρρευματικός αντιρρητικός
αντιρυτιδικός αντισεισμικός αντισεξουαλικός αντισημιτικός αντισηπτικός
αντισκωριακός αντισοβιετικός αντισπασμωδικός αντισταθμίσιμος αντισταθμιστικός
αντιστατικός αντιστικτικός αντιστιξιακός αντιστρέψιμος αντιστρατιωτικός
αντιστυλωμένος αντισυλληπτικός αντισυμβαλλόμενος αντισυμβατικός
αντισυμμοριακός αντισυνδικαλιστικός αντισυνταγματικός αντισυστημικός
αντιτάνκ αντιτάξιμος αντιτακτός αντιτετανικός αντιτοξικός αντιτορπιλικός
αντιτράστ αντιτραπεζικός αντιτριβικός αντιτρομοκρατικός αντιτυφικός
αντιφασιστικός αντιφατικός αντιφεμινιστικός αντιφθισικός αντιφιλελεύθερος
αντιφλεγμονώδης αντιφλογιστικός αντιφρονών αντιφυλετικός αντιφυλλοξηρικός
αντιφυσικός αντιφωνικός αντιχαλαζικός αντιχολερικός αντιχριστιανικός
αντλησιοταμιευτικός αντλητήριος αντλιοφόρος αντούβιανος αντρίκειος αντρίκιος
αντρείος αντρειωμένος αντρικός αντρωμένος αντρόπιαστος αντωνυμικός αντωπός
ανυιοθέτητος ανυμνητικός ανυπάκοος ανυπάκουος ανυπέρβλητος ανυπέρθετος
ανυποθήκευτος ανυπολόγιστος ανυπομόνευτος ανυποστήρικτος ανυποστήριχτος
ανυποχώρητος ανυποψίαστος ανυπόγραφος ανυπόδητος ανυπόθετος ανυπόθηκος
ανυπόληπτος ανυπόμονος ανυπόνοιαστος ανυπόστατος ανυπόσχετος ανυπόταγος
ανυπόταχτος ανυπόφερτος ανυπόφορος ανυσματικός ανυστερόβουλος ανυψωτικός
ανωφέλετος ανωφέλευτος ανωφέλητος ανωφελής ανωφελώς ανωφερής ανωφερικός
ανόθευτος ανόμοιος ανόργανος ανόργητος ανόργιστος ανόργωτος ανόρεκτος
ανόσιος ανότιστος ανύμφευτος ανύπανδρος ανύπαντρος ανύπαρκτος ανύπαρχτος
ανύποπτος ανύσταγος ανύστακτος ανύσταχτος ανύχτωτος ανώδυνος ανώμαλος ανώνυμος
ανώτατος ανώτερος ανώφελος αξάκριστος αξάπλωτος αξάφριστος αξέμπλεχτος
αξέχαστος αξήγητος αξήλωτος αξίδιαστος αξίνιστος αξεδίψαστος αξεδιάκριτος
αξεδιάλυτος αξεθύμαστος αξεκαθάριστος αξεκόλλητος αξελόγιαστος αξεμάτιαστος
αξεμυάλιστος αξεπάστρευτος αξεπέραστος αξεπλέρωτος αξεπλήρωτος αξεπούλητος
αξεσκάλιστος αξεσκέπαστος αξεσκόλιστος αξετίμητος αξετύλιχτος αξεφιτίλιστος
αξεφούρνιστος αξεχαρβάλωτος αξεχώριστος αξημέρωτος αξιέπαινος αξιέραστος
αξιαζούμενος αξιαζόμενος αξιακός αξιανάγνωστος αξιογέλαστος αξιοδάκρυτος
αξιοζήλευτος αξιοθέατος αξιοθαύμαστος αξιοθησαύριστος αξιοθρήνητος
αξιοκαταφρόνετος αξιοκαταφρόνητος αξιοκατηγόρητος αξιοκρατικός αξιολάτρευτος
αξιολογικός αξιολογούμενος αξιολογών αξιολύπητος αξιομίμητος αξιομίσητος
αξιομνημόνευτος αξιοπαρατήρητος αξιοπερίεργος αξιοπεριφρόνητος αξιοποιήσιμος
αξιοπρεπής αξιοπρόσεκτος αξιοπρόσεχτος αξιοσέβαστος αξιοσημείωτος
αξιοτράβηχτος αξιωματικός αξιόλογος αξιόμαχο αξιόμαχος αξιόμεμπτος αξιόμισθος
αξιόπλοος αξιόποινος αξιόπρεπος αξιότιμος αξιόχρεος αξιώτικος αξομολόγητος
αξονικός αξονοειδής αξονομετρικά αξονομετρικός αξονοσυμμετρικός αξούριστος
αξόδευτος αξόδιαστος αξόμπλιαστος αξόρκιστος αξόφλητος αξύλευτος αξύλιστος
αξύριστος αοίδιμος αοριστικός αοριστολογικός αορτικός αορτολαγόνιος
απάγγειος απάγκειος απάγκιος απάγωτος απάδων απάλιωτος απάνεμος απάνθρωπος
απάρθενος απάστρευτος απάστωτος απάτητος απάτορας απάτριος απάτωρ απάχικος
απένθητος απένταρος απέξω απέραντος απέραστος απέριττος απέταλος απέχων
απίθανος απίκραντος απίσσωτος απίστευτος απίστωτος απαίδευτος απαίνευτος
απαγής απαγγελτικός απαγκιστρωτικός απαγορευτικός απαγωγικός απαγωγός
απαζάρευτος απαθής απαιδαγώγητος απαισιόδοξος απαισιόμορφος απαισιότατος
απαιτητός απαλάμιστος απαλειπτικός απαλλακτικός απαλλαχτικός απαλλοτριώσιμος
απαλός απαλόχνουδος απανινός απαντητικός απαντλητικός απανωτός απαξάπας
απαπούτσωτος απαράβαλτος απαράβατος απαράβλητος απαράγγελτος απαράγραπτος
απαράγραφτος απαράδεκτος απαράδεχτος απαράδοτος απαράθετος απαράκαμπτος
απαράλειπτος απαράληπτος απαράλλακτος απαράλλαχτος απαράμιλλος απαράσκευος
απαρέμφατος απαρένθετος απαραίτητος απαραβίαστος απαραγνώριστος
απαρακάλεστος απαρακάλετος απαρακίνητος απαρακολούθητος απαρακράτητος
απαραλλήλιστος απαραμείωτος απαραμύθητος απαραπλάνητος απαραποίητος
απαρασημοφόρητος απαρασκεύαστος απαρατήρητος απαραφύλακτος απαραφύλαχτος
απαραχάραχτος απαραχώρητος απαρεμπόδιστος απαρεμφατικός απαρενόχλητος
απαρηγόρητος απαριθμήσιμος απαριθμητός απαρνητικός απαρομοίαστος απαρουσίαστος
απαρτικός απαρόμοιαστος απαρόρμητος απαρώδητος απασάλειφτος απασπάλιστος
απασσάλωτος απαστράπτων απασχολήσιμος απατίκωτος απατεώνικος απατηλός
απαυτός απείθαρχος απείραγος απείρακτος απείραχτος απεγνωσμένος απειθάρχητος
απειθαρχικός απεικαστικός απεικονισματικός απεικονιστικός απειλητικός
απειράριθμος απειροδιάστατος απειροελάχιστος απειρομεγέθης απειροπόλεμος
απειροστός απειροσύνθετος απειρόγαμος απειρόκαλος απειρότεχνος απειρώνυμος
απεκκριτήριος απεκκριτικός απελέκητος απελαθείς απελασμένος απελαυνόμενος
απελευθερωτικός απελπιστικός απενθής απεράτωτος απερίγραπτος απερίγραφτος
απερίθαλπτος απερίσκεπτος απερίσκεφτος απερίσπαστος απερίτεχνος απερίτμητος
απερίφραστος απερίφραχτος απεραθίτικος απεργιακός απεργοσπαστικός
απεριγέλαστος απερινόητος απεριοδικός απεριποίητος απεριόριστος απερπάτητος
απευκταίος απεχθής απηνής απηχητικός απιδόσχημος απιοειδής απισσάριστος
απισχναντικός απλάνευτος απλάνιστος απλέρωτος απλήγωτος απλήθυντος απλήρωτος
απλανής απλειστηρίαστος απλημμύριστος απληροφόρητος απλησίαστος απλογραφικός
απλοποιημένος απλοποιητικός απλοχέρης απλοϊκός απλούμιστος απλούς απλούστερος
απλωτός απλός απλόχερος απλόχωρος αποίητος αποίκιλτος αποίμαντος αποβατικός
αποβιώσας αποβλακωτικός αποβλητέος αποβολιμαίος αποβραδινός αποβροχάρης
απογαλακτισμένος απογεματινός απογευματινός απογοητευτικός απογραμμικός
αποδέλοιπος αποδαύτος αποδείξιμος αποδειγμένος αποδεικτικός αποδεικτός
αποδεκτικός αποδεκτός αποδεχτός αποδημητήρια αποδημητικός αποδιοπομπαίος
αποδοκιμαστικός αποδομήσιμος αποδομητικός αποδοτικός αποδυναμωτικός αποδόσιμος
αποθήκευτρα αποθαρρυντικός αποθεματικός αποθετήριος αποθετικός αποθεωτικός
αποθηκευτικός αποθορυβοποιήσιμος αποικιακός αποικιοκρατικός αποικιστικός
αποκάτω αποκαλυπτήριος αποκαλυπτικός αποκαρδιωτικός αποκατιανός αποκατινός
αποκεντρωτικός αποκεφαλισθείς αποκλίνων αποκλειστικός αποκληρωτικός
αποκορυφωτικός αποκριάτικος αποκριτικός αποκρουστικός αποκρυφικός
αποκτηνωτικός απολέμητος απολέμιστος απολήψιμος απολίτικος απολίτιστος
απολεπισμένος απολεπιστικός απολεστικός απολιτίκ απολιτικός απολλαπλασίαστος
απολογιστικός απολυμαντήριος απολυμαντικός απολυτήριος απολυτρωτικός απολυτός
απομαχικός απομνημονευματικός απομνημονευματογραφικός απομνημονευτικός
απομονάχος απομοναχός απομονωμένος απομονωτικός απομυελινωτικός απομυζητικός
απομόναχος απονήρευτος αποναρκωτικός απονεκρωτικός απονευρωτικός απονύχτερος
αποξηραντικός αποπανινός αποπεμπτικός αποπλανητικός αποπληθωρισμένος
αποπνικτικός αποπνιχτικός αποπροσανατολιστικός αποριξιμιός απορρέων
απορριμματοφόρος απορριξιμιός απορριπτέος απορροφητικός απορρυθμιστικός
αποσαθρωτικός αποσαφηνιστικός αποσβεσθείς αποσβεστικός αποσιωπητικός
αποσκιαδερός αποσκληρυντικός αποσμηκτικός αποσμητικός αποσοτικοποίητος
αποσπασματικός αποσπερνός αποστάξιμος αποστέλλων αποσταγματικός
αποστακτικός αποστατικός αποστεγνωτικός αποστειρωτικός αποστηματώδης
αποστομωτικός αποστραγγιστικός αποστρατευτέος αποστρατεύσιμος αποσυμφορητικός
αποσυνδετικός αποσυνθετικός αποσυρτός αποσχιστικός αποτέτοιος αποταμιευτικός
αποτελειωμένος αποτελεσμένος αποτελεσματικός αποτελματικός αποτελούμενος
αποτρεπτικός αποτριχωτικός αποτροπαϊκός αποτρόπαιος αποτυπωτικός αποτυχών
αποφασιστικός αποφατικός αποφθεγματικός αποφοιτήσας αποφοιτών αποφολιδωτικός
αποφραχτικός αποφώλιος αποχαιρετιστήριος αποχαιρετιστικός αποχαυνωτικός
αποχετευτικός αποχιονιστικός αποχρεμπτικό αποχρεμπτικός αποχρωσιακός
αποχυμένος αποχωματώνω αποχωριστικός αποψεσινός αποψιλωτικός αποψινός
απούλητος απράγμων απραγμάτωτος απραγματοποίητος απρεπής απριλιάτικος
απριλινός απριόνιστος απροΐδωτος απροάσπιστος απροίκιστος απροβίβαστος
απρογραμμάτιστος απροδιαίσθητος απροειδοποίητος απροεξόφλητος απροετοίμαστος
απροκατάληπτος απρολόγητος απρολόγιστος απρομελέτητος απρονόητος
απροπαράσκευος απροπαρασκεύαστος απροπόνητος απροσάρμοστος απροσάρτητος
απροσανατόλιστος απροσγείωτος απροσδιόνυσος απροσδιόριστος απροσδόκητος
απροσκάλεστος απροσκύνητος απροσμάχητος απροσμέτρητος απροσπέλαστος
απροσποίητος απροστάτευτος απροσχεδίαστος απροσχημάτιστος απροσωπόληπτος
απροφύλακτος απροφύλαχτος απροχώρητος απρωτοκόλητος απρωτοκόλλητος απρόβλεπτος
απρόθεσμος απρόθετος απρόθυμος απρόκλητος απρόκοπος απρόκοφτος απρόοπτος
απρόσβλητος απρόσεκτος απρόσεχτος απρόσημος απρόσθετος απρόσιτος απρόσκλητος
απρόσληπτος απρόσμενος απρόσοδος απρόσφορος απρόσωπος απρόφερτος απτικός
απτός απυρπόλητος απυρόβλητος απωανατολικός απωθητικός απωμάτιστος απόβλητος
απόγειος απόγκρεμνος απόκεντρος απόκληρος απόκοσμος απόκοτος απόκρημνος
απόλεμος απόλυτος απόμακρος απόμαχος απόμερος απόμονος απόμπευτος απόντιστος
απόπληκτος απόπληχτος απόρθητος απόρρητος απόσκεπος απόσκιο απόσκιος απότακτος
απότιστος απότοκος απότολμος απότομος απόφοιτος απύθμενος απύλωτος απύραυλος
απύρηνος απύρωτος απώγων απών απώτατος απώτερος αράγιστος αράθυμος αράντιστος
αρέντιγος αρίγωτος αρίφνητος αραβικός αραβόφωνος αραδιαστός αραιοκατοικημένος
αραιός αραμαϊκός αραξοβολημένος αραποσίτινος αραχνοΰφαντος αραχνοειδής
αραχνοκεντημένος αραχνοφοβικός αραχνώδης αρβανίτικος αρβανιτοβλάχικος
αρβαντοβλάχικος αργίτης αργίτικος αργείος αργείτικος αργιλικός αργιλούχος
αργοκίνητος αργολικός αργοναυτικός αργοξύπνητος αργοτάξιδος αργούτσικος
αργυρόλευκος αργυρός αργυρόχροος αργυρώνητος αργόμισθος αργός αργόστροφος
αργόσχολος αρδευτικός αρδεύσιμος αρειανός αρειμάνιος αρεστός αρετολογικός
αρευστοποίητος αρζαντέ αρθρικός αρθριτικός αρθρογραφικός αρθροσκοπικός
αριβίστικος αριβιστικός αριθμήσιμο αριθμητικός αριθμητός αριθμοδεικτικός
αριστερίστικος αριστεροδέξιος αριστεροτίμονος αριστερός αριστερόστροφος
αριστοτέλειος αριστοτελικός αριστοτεχνικός αριστουργηματικός αριστοφάνειος
αριστούχος αριφραδής αριός αρκαδικός αρκετός αρκουδίσιος αρκτικός αρκτικός
αρμενικός αρμενοβυζαντινός αρμενοφόρος αρμονικός αρμοστικός αρμοστός αρμυρός
αρμόνιος αρμόσιμος αρνίσιος αρναούτης αρνησίθεος αρνησίθρησκος αρνησίπατρις
αροκάνιστος αρπακολλατζίδικος αρπακτικός αρπαχτικός αρπαχτός αρρίζωτος αρραγής
αρρενωπός αρρενόφωνος αρρωστιάρης αρρωστιάρικος αρρωστομανής αρρωστοφοβικός
αρρύπαντος αρσενικοθήλυκος αρσενικούχος αρσενικός αρτίγονος αρτεσιανός
αρτηριογραφικός αρτηριοσκληρωτικός αρτηριοφλεβικός αρτηριοφλεβώδης
αρτιγενής αρτιμελής αρτισύστατος αρτύσιμος αρυμοτόμητος αρυτίδωτος αρφανός
αρχέγονος αρχέτυπος αρχαίος αρχαγγέλινος αρχαιογεωμορφολογικός αρχαιοελληνικός
αρχαιολατρικός αρχαιολογικός αρχαιομαθής αρχαιομανής αρχαιοπινής αρχαιοπρεπής
αρχαιόπρεπος αρχαιόσυλος αρχαιότερος αρχαιότροπος αρχαιότροπος αρχαϊκός
αρχετυπικός αρχηγικός αρχιδάτος αρχιδουκικός αρχιεπισκοπικός αρχιερατικός
αρχιλόχειος αρχιμήδειος αρχιτεκτονικός αρχολίπαρος αρχομανής αρχοντικός
αρχοντοχωριάτικος αρωματικός αρωματώδης αρωμουνικός αρύπαντος αρύς αρώσιμος
ασάλιωτος ασάπιστος ασέληνος ασέλωτος ασήκωτος ασήμαντος ασίγαστος ασίγητος
ασίκικος ασίμωτος ασίτευτος ασαβάνωτος ασαβούρωτος ασαγήνευτος ασαμάρωτος
ασαράντιστος ασατίριστος ασαφήνιστος ασαφής ασβάρνιστος ασβεστολιθικός
ασβεστώδης ασβολερός ασεβής ασεισμικός ασελγής ασελιδοποίητος ασεξουαλικός
ασημένιος ασημής ασημείωτος ασημοκαπνισμένος ασημόχρωμος ασηπτικός
ασθενής ασθενικός ασθματικός ασιανός ασιατικός ασιγούρευτος ασιδέρωτος
ασκάλωτος ασκέπαστος ασκίαστος ασκανδάλιστος ασκαντάλιστος ασκελής ασκεπής
ασκημομούρικος ασκημούλης ασκημούτσικος ασκητικός ασκιαγράφητος ασκλάβωτος
ασκοειδής ασκορβικός ασκοτείνιαστος ασκούντητος ασκούπιστος ασκούριαστος
ασκόνιστος ασκόπευτος ασκόρπιστος ασκότιστος ασμάλτωτος ασμίκρυντος ασμίλευτος
ασοβάρευτος ασοβάτιστος ασορτί ασουλούπωτος ασούβλιστος ασούρωτος ασούσσουμος
ασπέδιστος ασπίλωτος ασπαργάνωτος ασπαρτάριστος ασπαστός ασπιδοφόρος
ασπούδαχτος ασπριδερός ασπρομάλλης ασπροντυμένος ασπροπρόσωπος ασπρουλιάρης
ασπροφορεμένος ασπρόμαυρος ασπόνδυλος ασσυριακός ασσυροβαβυλωνιακός αστάθμητος
αστάρωτος αστέγαστος αστέγνωτος αστέναχτος αστέρευτος αστέρινος αστέριωτος
αστήριχτος αστίλβωτος ασταθής αστακόχρωμος ασταμάτηγος ασταμάτητος
ασταύρωτος αστείος αστείρευτος αστερέωτος αστεροειδής αστερωτός αστερόεις
αστεφάνωτος αστεφής αστηλίτευτος αστιατρικός αστιγμάτιστος αστιγματικός
αστικός αστοίβαστος αστοίβαχτος αστοιχείωτος αστοχισμένος αστράγγιστος
αστρίφωτος αστραπιαίος αστραποκαμένος αστραπόμορφος αστρατολόγητος
αστραφτερός αστρικός αστροβριθής αστροθόλωτος αστρολογικός αστρομετρικός
αστρονομικός αστροσκέπαστος αστροσκεπής αστροστεφάνωτος αστροστόλιστος
αστροφυσικός αστροφυσικός αστροφώτιστος αστρόγιομος αστρόσπαρτος αστρόφεγγος
αστυνομικός αστόλιστος αστόμωτος αστόχαστος ασυγκάλυπτος ασυγκέντρωτος
ασυγκίνητος ασυγκράτητος ασυγκρότητος ασυγχρόνιστος ασυγχρώτιστος ασυγχώνευτος
ασυγύριστος ασυζήτητος ασυκοφάντητος ασυλλόγιστος ασυμβίβαστος ασυμβούλευτος
ασυμμάζωχτος ασυμμετρικός ασυμμόρφωτος ασυμπάθητος ασυμπάθιστος ασυμπίεστος
ασυμπλήρωτος ασυμπτωματικός ασυμπτωτικός ασυμφιλίωτος ασυμφώνητος ασυμψήφιστος
ασυνάρτητος ασυνάχωτος ασυνήθης ασυνήθιστος ασυνίζητος ασυναίρετος
ασυναγώνιστος ασυνδιάλλακτος ασυνδιάλλαχτος ασυνδύαστος ασυνείδητος
ασυνεπής ασυνεχής ασυνθηκολόγητος ασυννέφιαστος ασυντέλεστος ασυντήρητος
ασυνταύτιστος ασυντρόφευτος ασυντόνιστος ασυνόδευτος ασυνόρευτος ασυρματοφόρος
ασυσκότιστος ασυσπείρωτος ασυστηματοποίητος ασυσχέτιστος ασυχώρετος ασφάλτινος
ασφαλής ασφαλίσιμος ασφαλιστήριος ασφαλιστικός ασφαλτικός ασφαλτούχος
ασφαλτώδης ασφουγγάριστος ασφούγγιστος ασφούγγιχτος ασφράγιστος ασφυκτικός
ασφυχτικός ασχεδίαστος ασχημάτιστος ασχημομούρης ασχημομούρικος ασχημούλης
ασχημούτσικος ασχημότερος ασχολίαστος ασωφρόνιστος ασόβαρος ασόδιαστος
ασύγκλητος ασύγχρονος ασύδοτος ασύλητος ασύλληπτος ασύμβατος ασύμβλητος
ασύμπτυκτος ασύμπτωτος ασύμφορος ασύμφωνος ασύνακτος ασύναπτος ασύναχτος
ασύνειδος ασύνετος ασύνορος ασύντακτος ασύνταχτος ασύντμητος ασύντριπτος
ασύρματος ασύστατος ασύστολος ασύχαστος ασύχναστος ασώματος ασώπαστος ατάιστος
ατάρακτος ατάραχος ατάραχτος ατάσθαλος ατάστωτος ατέκμαρτος ατέλειωτος
ατέντωτος ατέρμονας ατέρμονος ατέρμων ατίθασος ατίμητος ατίναχτος αταίριαγος
αταίριαχτος αταβάνωτος αταβιστικός ατακτοποίητος αταλάντευτος αταλαιπώρητος
αταξικός αταξινόμητος αταπείνωτος αταρίχευτος αταχτοποίητος αταύτιστος
ατεζάριστος ατεκμηρίωτος ατελέσφορος ατελής ατελείωτος ατελειοποίητος
ατελεύτητος ατελώνιστος ατεμάχιστος ατενής ατερμάτιστος ατζαμής ατζαμίδικος
ατηγάνιστος ατηλεγράφητος ατημέλητος ατιθάσευτος ατιμαστικός ατιμολόγητος
ατιμώρητος ατιτλοφόρητος ατλάζινος ατλαζένιος ατλαζωτός ατλαντικός ατμήλατος
ατμοκίνητος ατμοπλοϊκός ατμοσφαιρικός ατμώδης ατοίμαστος ατοιχοκόλλητος
ατομικός ατομιστικός ατομοκρατικός ατονικός ατοξικός ατοπικός ατοποθέτητος
ατρίχωτος ατραγούδητος ατραγούδιστος ατρακάριστος ατρακτοειδής ατρατάριστος
ατριβής ατροποποίητος ατροφικός ατρόμητος ατρόχιστος ατρύγητος ατρύπητος
ατσάλινος ατσάπιστος ατσίκνιστος ατσαλένιος ατσεκούρωτος ατσιγάριστος
ατσουρούφλιστος ατσούγκριστος ατσούμπαλος ατσούτσουνος αττικίζων αττικιστικός
ατυχής ατόλμητος ατόνιστος ατόρνευτος ατός ατόφιος ατύλιχτος ατύπωτος
αυγινός αυγοειδής αυγουλάτος αυγουλωτός αυγουστιάτικος αυγουστιανός
αυγόσχημος αυθάδης αυθάδικος αυθαίρετος αυθαδέστατος αυθεντικός αυθυπόστατος
αυθύπαρκτος αυθύπαρχτος αυλακωτός αυλικός αυλόδουλος αυξητικός αυξομειωτικός
αυριανός αυστηρός αυστραλέζικος αυστριακός αυτάρεσκος αυτάρκης αυτήκοος
αυταπάντητος αυταπόδεικτος αυταπόδειχτος αυταρχικός αυτενέργητος αυτενεργός
αυτεξούσιος αυτεπάγγελτος αυτιστικός αυτοάνοση αυτοάνοσος αυτοακυρωτικός
αυτοαναφορικός αυτοαπαρνημένος αυτοβιογραφικός αυτογραφικός αυτοδίδακτος
αυτοδίκαιος αυτοδημιούργητος αυτοδιαχειριστικός αυτοδικαίωτος αυτοδιοίκητος
αυτοδιοικούμενος αυτοδιορισθείς αυτοδιόριστος αυτοδραστικός αυτοδύναμος
αυτοεκπληρούμενος αυτοεκφυλιστικός αυτοεξυπηρετούμαι αυτοεξόριστος
αυτοκέφαλος αυτοκίνητος αυτοκαθοριστικός αυτοκαταστροφικός αυτοκινητικός
αυτοκινούμενος αυτοκρατορικός αυτοκριτικός αυτοκτονικός αυτοκυβέρνητος
αυτοκόλλητος αυτοματικός αυτονομιστικός αυτονόητος αυτοπαθής αυτοπαθητικός
αυτοπροαίρετος αυτοπροωθούμενος αυτοπρόσωπος αυτοσαρκαστικός αυτοσυγκράτητος
αυτοσχέδιος αυτοσχεδίαστος αυτοτελής αυτοτροφικός αυτοφυής αυτοχειριαστικός
αυτούσιος αυτόβουλος αυτόγραφος αυτόδηλος αυτόδραση αυτόκλητος αυτόματος
αυτόμοιος αυτόνομος αυτόνοος αυτόρριζος αυτότροφος αυτόφυτος αυτόφωρος
αυτόχθων αυχενικό αυχενικός αυχμηρός αφάγωτος αφάνταστος αφάσκιωτος αφάτνωτος
αφέσιμος αφίλευτος αφίλητος αφίλιωτος αφίμωτος αφαιρέσιμος αφαιρετέος
αφαιρετός αφακέλωτος αφανάτιστος αφανέρωτος αφανής αφανιστικός αφασικός
αφγανικός αφεγγής αφειδής αφειδώλευτος αφελής αφεντάδικος αφεντικός αφερέγγυος
αφετήριος αφετηριακός αφηγηματικός αφηγητικός αφθονοπάροχος αφθώδης
αφιεραρχημένος αφιερωματικός αφιερωτήριος αφιερωτικός αφιλάνθρωπος αφιλοκερδής
αφιλονίκητος αφιλοσόφητος αφιλοχρήματος αφιλτράριστος αφιλόκαλος αφιλόκερδος
αφιλόξενος αφιλόπατρις αφιλόστοργος αφιλότεχνος αφιλότιμος αφκιασίδωτος
αφοδράριστος αφομοιωτικός αφομοιώσιμος αφοπλιστικός αφοριστικός αφορμάριστος
αφούντωτος αφούρνιστος αφράτος αφρεσκάριστος αφρικάνικος αφρικανικός
αφριστός αφροαμερικανικός αφρογέννητος αφροδίσιος αφροδισιακός αφρονημάτιστος
αφρούρητος αφρυγάνιστος αφρόντιστος αφρόπλαστος αφρώδης αφτιασίδωτος αφυής
αφυλετικός αφυπνιστικός αφωνόληκτος αφωνόληχτος αφωταγώγητος αφόρετος αφόρητος
αφόρτωτος αφύλακτος αφύλαχτος αφύσικος αφύτευτος αφύτρωτος αφώτιστος
αχάλαγος αχάλαστος αχάραγος αχάρακτος αχάραχτος αχάριστος αχίλλειος αχαΐρευτος
αχαλιναγώγητος αχαμνός αχανής αχαράκωτος αχαρακτήριστος αχαραχτήριστος
αχαρτοσήμαντος αχαϊκός αχείμαντος αχείμαστος αχειράφετος αχειρίδωτος
αχειραφέτητος αχειροποίητος αχειροτόνητος αχειρούργητος αχερόντειος αχερόντιος
αχθοφορικός αχιόνιστος αχλάμυδος αχλεύαστος αχλωρωτικός αχνιστός αχνοφώτιστος
αχνούδωτος αχνός αχνόφωτος αχορήγητος αχορτάριαγος αχορτάριαστος αχουζούρευτος
αχρήματος αχρείαστος αχρείος αχρειόγλωσσος αχρειόστομος αχρεώστητος
αχρησίμευτος αχρησιμοποίητος αχρονολόγητος αχρωμάτιστος αχρωματικός αχρόνιαγος
αχρόνιστος αχτένιστος αχτιδωτός αχτύπητος αχυρένιος αχυροστρωμένος αχυρώδης
αχόλιαστος αχόρταγος αχόρταστος αχύλωτος αχώνευτος αχώρετος αχώρητος αχώριστος
αψήφιστος αψίθυμος αψίκορος αψίχολος αψαλίδιστος αψαχούλευτος αψεγάδιαστος
αψηλάφητος αψηλός αψιδοειδής αψιδωτός αψιθυμικός αψιμυθίωτος αψιχάλιστος
αψυχολόγητος αψυχοπόνετος αψύς αψύχραντος αψύχωτος αψώνιστος αόμματος αόρατος
αύλειος αύξων αύτανδρος βάκρινος βάναυσος βάρβαρος βάρυπνος βάσιμος βάσκανος
βέβηλος βέλγικος βέλτιστος βένετος βέρος βίαιος βαβυλωνιακός βαβυλώνιος
βαγαπόντης βαγαπόντικος βαθμιαίος βαθμιδωτός βαθμολογικός βαθμούχος
βαθουλωτός βαθουλός βαθυγάλανος βαθυκόκκινος βαθυμετρικός βαθυπράσινος
βαθυσκαφής βαθυστόχαστος βαθύγνωμος βαθύνους βαθύπλουτος βαθύρριζος βαθύς
βαθύσκιωτος βαθύτατος βαθύτερος βαθύφωνος βαθύχρωμος βακιλικός βακιλόμορφος
βακούφικος βακτηριακός βακτηριοκτόνος βακτηριολογικός βακτηριοστατικός
βακχικός βαλβιδοπλαστικός βαλκανικός βαλλιστικός βαλτικός βαλτός βαμβακένιος
βαμπακερός βαναδιούχος βανδαλικός βαπορίσιος βαπτιστικός βαρήκοος βαραθρώδης
βαρβαρικός βαρβαρόφωνος βαρελίσιος βαρεσάρης βαρετός βαρηλάτης βαριούχος
βαρομετρικός βαρυγενετικός βαρυγεννητικός βαρυγομαρκάρης βαρυονική βαρυονικός
βαρυπενθών βαρυσήμαντος βαρυστόμαχος βαρυτικός βαρυτοαδράνειος
βαρυτοαδρανικός βαρυχρονικός βαρύγδουπος βαρύθυμος βαρύνων βαρύς βαρύτατος
βαρύτιμος βαρύτονος βασαλτικός βασανιστικός βασικοκυτταρικός βασικός βασιλικός
βασιλόφρονας βασιλόφρων βασκαντικός βασταγερός βατραχοειδής βαττολόγος βατός
βαυαρικός βαφικός βαφτιστικός βαϊοφόρος βγιενικός βδελλάτος βδελυρός βδελυρός
βεβαιωτικός βεβαιόπιστος βεβαιότατος βεβαιότερη βεβαιότερο βεβαιότερος
βεβαρυμένος βεγγαλέζικος βεγγαλικός βεδικός βελγικός βελοειδής βελονοειδής
βελονωτός βελουδένιος βελουτέ βελούδινος βελτιωτικός βελτιόδοξος βελτιώσιμος
βενεδικτίνος βενετικός βενετσιάνικος βενζινοκίνητος βενζοϊκός βενθικός
βενθόβιος βενιζελικός βεραμάν βεριτάμπλ βερμπαλιστικός βεροιώτικος βηματικός
βησιγοτθικός βιαστικός βιβλιακός βιβλιεκδοτικός βιβλιεμπορικός βιβλικός
βιβλιογραφικός βιβλιοδετικός βιβλιοκριτικός βιβλιομανής βιβλιοπωλικός
βιδωτός βιενέζικος βιεννέζικος βιετναμέζικος βιετναμικός
βικτοριανός βιλλαράς βιντεομανής βιντεοσκοπικός βινυλικός βιοαποδομήσιμος
βιογενής βιογεωγραφικός βιογραφικός βιοδιασπάσιμος βιοδραστικός βιοδυναμικός
βιοκλιματικός βιολέ βιολετής βιολετί βιολογικός βιομετρικός
βιομηχανικός βιομηχανοποιήσιμος βιομοριακός βιονικός βιονομικός βιοποιοτικός
βιοπτικός βιορυθμικός βιοτεχνικός βιοτεχνολογικός βιοτικός βιοφαρμακευτικός
βιοψυχοκοινωνικός βιοϊατρικός βιρμανικός βισμουθιούχος βιταλιστικός
βιταμινούχος βιτριολικός βιτσιόζικος βιτσιόζος βιωματικός βιώσιμος βλάστημος
βλάχικος βλαβερός βλαισόπους βλαισός βλακώδης βλαξ βλαπτικός βλαστητικός
βλαχικός βλαχομοδάτος βλαχόφωνος βλαψίφρων βλεννογόνος βλεννολυτικός
βλεννώδης βλεφαριδοφόρος βλεφαρικός βλητικός βλογιάρης βλογιοκομμένος βλοσυρός
βοδινός βοερός βοηθητικός βοημικός βοιωτικός βολβοειδής βολβόσχημος βολβώδης
βολικός βολιώτικος βολταϊκός βολφραμιούχος βομβαρδιστικός βομβιδοφόρος
βομβυκοτροφικός βοοειδής βορβοροφάγος βορβορώδης βορειανατολικός
βορειοανατολικός βορειοατλαντικός βορειοαφρικανικός βορειοβιετναμικός
βορειοειρηνικός βορειοελλαδικός βορειοευρωπαϊκός βορειοηπειρωτικός
βορειοσιατικός βορικό βορινός βοριούχος βοσκήσιμος βοσνιακός βοστρυχοειδής
βοστρυχώδης βοτανικός βοτανολογικός βοτουλινικός βοτρυοειδής βοτρυώδης
βουβαλίσιος βουβωνικός βουβωνοκηλικός βουβός βουδικός βουδιστικός βουερός
βουλγάρικος βουλγαρικός βουλγαρόφωνος βουλευτικός βουλησιαρχικός βουλητικός
βουνίσιος βουνώδης βουτηχτός βουτυράτος βουτυρένιος βουτυρικός βουτυρώδης
βοϊδινός βοϊδομάτης βοώδης βραβεύσιμος βραγχιακός βραδιάτικος βραδιανός
βραδυκίνητος βραδυφλεγής βραδύγλωσσος βραδύκαυστος βραδύνους βραδύς
βρακοφόρος βραστερός βραστός βραχιολάτος βραχιόνιος βραχμανικός βραχνός
βραχοσύντριφτος βραχυγραφικός βραχυκατάληκτος βραχυλογικός βραχυμεσοχρόνιος
βραχυπρόθεσμος βραχυχρόνιος βραχύβιος βραχύινος βραχύκαννος βραχύκερκος
βραχύς βραχύσωμος βραχύτερος βραχύφωνος βραχύχρονος βραχώδης βρεγμένος
βρεγματικός βρετανικός βρετονικός βρεφικός βρεφοκομικός βρεφονηπιακός βρεφώδης
βρογχικός βρογχοκηλικός βρογχοκυψελιδικός βρογχολογικός βρογχοϋπεζωκοτικός
βρομιάρης βρομιάρικος βρομογούρουνο βρομοπόδαρος βρομόγλωσσος βρομόστομος
βροντόφωνος βροντώδης βροχερός βροχομετρικός βρυξελλιώτικος βρυώδης βρωμερός
βρόμικος βρόχινος βρώμικος βρώσιμος βυζαντινολογικός βυζαντινοπρεπής
βυζαντινότροπος βυθομετρικός βυθοσκοπικός βυρσοδεψικός βυσσινής βυτιοφόρος
βόειος βόρειος βύθιος βύρσινος βύσσινος γάνωμα γάργαρος γέμελος γέρικος γήινος
γίντις γαβαθωτός γαγγλιώδης γαγγραινικός γαγγραινώδης γαδολινιούχος γαζωτός
γαιοκτητικός γαιοφάγος γαιώδης γαλάζιος γαλάριος γαλήνιος γαλίφης γαλίφικος
γαλαζοπράσινος γαλαζωπός γαλαθηνός γαλακταγωγός γαλακτερός γαλακτικός
γαλακτοδίαιτος γαλακτοειδής γαλακτοκομικός γαλακτοπαραγωγικός γαλακτοπαραγωγός
γαλακτοποιός γαλακτοφόρος γαλακτόχρωμος γαλακτώδης γαλαναδιώτικος γαλανομάτης
γαλανόλευκος γαλανός γαλαξιακός γαλαξιδιώτικος γαλατερός γαλατικός γαλβανιζέ
γαληνός γαλλικός γαλλιούχος γαλλομαθής γαλλοτραφής γαλλόφιλος γαλλόφωνος
γαμάτος γαμήλιος γαμπριάτικος γαμψός γαμψώνυχος γαντζωτός γαντοφορεμένος
γαργαριστός γαργερός γαρμπάτος γαρμπόζος γαστρίμαργος γαστρεντερικός
γαστρικός γαστρονομικός γαστροοισοφαγικός γατίσιος γατόφιλος γαϊδουρίσιος
γαϊδουρόφωνος γαϊτανοφρύδης γαϊτανωτός γδυμνός γδυτός γειρτός γειτονικός
γελαστικός γελαστός γελοίος γελοιογραφικός γελοιώδης γεμάτος γεματούτσικος
γενάτος γενέθλιος γεναριάτικος γενεαλογικός γενεσιουργικός γενεσιουργός
γενετικός γενικευτικός γενικεύσιμος γενικολογικός γενικοσχετικός γενικόλογος
γενναίος γενναιόδωρος γενναιόκαρδος γενναιόφρων γενναιόψυχος γεννητικός
γενομικός γενόσημος γερακίσιος γεραλέος γερανοφόρος γεραρός γερμανικός
γερμανομαθής γερμανοτραφής γερμανόφιλος γερμανόφωνος γερογκρινιάρης
γεροντίστικος γεροντικός γεροντομπασμένος γεροξεκούτης γεροπαράξενος
γερουσιαστικός γερτός γερός γευστικός γεφυροπαρεγκεφαλιδικός γεφυρωτικός
γεωγραφικός γεωδαιτικός γεωδυναμικός γεωθερμικός γεωθερμοηλεκτρικός
γεωλογικός γεωμαγνητικός γεωμετρικός γεωπολιτικός γεωπονικός γεωργικός
γεωσύγχρονος γεωτεχνικός γεωτρητικός γεωφυσικός γεωχημικός γεωχωρικός γεώδης
γηθόσυνος γηπεδούχος γηραιός γηραιότερος γηραλέος γηριατρικός γηροκομικός
γιαγλίδικος γιακουτικός γιαλαντζί γιαλόκλειστος γιαννιτσιώτικος γιαννιώτικος
γιαχβικός γιαχνιστός γιγάντειος γιγάντιος γιγαντιαίος γιγαντόσωμος γιγαντώδης
γινωμένος γιομάτος γιορταστικός γιορτερός γιορτιάτικος γιορτινός
γιούνισεξ γκαβός γκαγκά γκαιμπελικός γκαμσίζης γκανγκστερικός γκανιάν γκαντέμα
γκαραντί γκαρδιακός γκεμπελικός γκινιαδόρος γκινιόζος γκλαμουράτος γκουρμέ
γκρίζος γκρενά γκριζογάλανος γκριζομάλλης γκριζομάτης γκριζοπράσινος γκριζωπός
γκροτέσκ γκροτέσκος γλήγορος γλίσχρος γλίτσιασμα γλαγολιτικός γλαρός γλαυκός
γληνός γλιστερός γλιτσερός γλιτσιάζω γλιτσιάρικος γλιτσιασμένος γλοιώδης
γλυκαιμικός γλυκανάλατος γλυκαντικός γλυκερός γλυκοαίματος γλυκομίλητος
γλυκοπύρηνος γλυκούλης γλυκούτσικος γλυκόηχος γλυκόλαλος γλυκόμορφος
γλυκόπικρος γλυκόπιοτος γλυκόπνοος γλυκός γλυκόφωνος γλυκύλαλος γλυκύμορφος
γλυκύφωνος γλυπτικός γλυπτός γλυφούτσικος γλυφός γλωσσάς γλωσσηματικός
γλωσσολογικός γλωσσομαθής γλωσσοπλαστικός γνήσιος γναθιαίος γναθικός
γναθοφόρος γναθοχειρουργικός γνευσιακός γνοιαστικός γνωμικός
γνωμοδοτικός γνωμολογικός γνωρίζον γνωρίζουσα γνωρίζων γνωσιακός
γνωσιολογικός γνωσιφόρος γνωστικιστικός γνωστικός γνωστός γνωστότατος γνώριμος
γοητευτικός γονατιστός γονατώδης γονεϊκός γονιδιωματικός γονικός γονιμοποιός
γονοτυπικός γονοχωριστικός γονυπετής γοργοεπήκοος γοργοκίνητος γοργοπόδαρος
γοργός γοργόφτερος γοτθικός γοτθισχιδής γουνάτος γουνοφόρος γουρλίδικος
γουρλομάτικος γουρλού γουρλωτός γουρουνίσιος γουρουνοειδής γουρουνομαθημένος
γουρσούζης γουρσούζικος γουστόζικος γούνινος γούρικος γούρμος γρήγορος
γραμματειακός γραμματιζούμενος γραμματικός γραμματισμένος γραμματολογικός
γραμμογραφικός γραμμοειδής γραμμοσκίαστος γραμμοσκιασμένος γραμμοϊσοδύναμος
γραμμώδης γρανίτινος γρανιτένιος γρανιτικός γρανιτώδης γραπτός γρατζουνισμένος
γραφίστικος γραφειακός γραφειοκρατικός γραφικός γραφιστικός γραφολογικός
γραώδης γρεβενιώτικος γρετίδικος γρινιάρης γριπικός γριπώδης γριφοειδής
γροιλανδικός γρουσούζης γρουσούζικος γρυπός γυάλινος γυαλένιος γυαλικός
γυθειάτικος γυμνασιακός γυμναστικός γυμνικός γυμνοσπέρματος γυμνόρριζος γυμνός
γυμνόσπερμος γυμνόστερνος γυμνόστηθος γυναίκειος γυναικάρεσκος γυναικίσιος
γυναικείος γυναικολογικός γυναικοπρεπής γυναικωτός γυναικόσπαρτος γυναικόφωνος
γυριστός γυρομαγνητικός γυψώδης γωνιαίος γωνιακός γωνιοκόρυφος γωνιωτός
γόνιμος γόρδιος γύφτικος γύψινος δάνειος δάφνινος δέντρινος δέσμιος δέων δήλος
δίβολος δίβουλος δίγαμος δίγλυφος δίγλωσσος δίγνωμος δίγραμμος δίδυμο δίδυμος
δίθυρος δίκαιος δίκαιος δίκαννος δίκαρτος δίκλινος δίκλωνος δίκοπος δίκορκος
δίκορφος δίκροκος δίκυκλος δίκυτος δίκωπος δίλοβος δίμηνος δίμορφος δίμουρος
δίπατος δίπλα δίπλευρος δίποδος δίπολος δίπορτος δίπρακτος δίπτερος δίπτυχος
δίπυρος δίριχτος δίσεκτος δίσεχτος δίσημος δίστηλος δίστιχος δίστοιχος
δίτιμος δίτομος δίτοξο δίτοξος δίτροχος δίφορος δίφυλλος δίφωνος δίχειλος
δίχηλος δίχρονος δίχρωμος δίχωρος δίωρος δαήμων δαίδαλος δαγκανιάρης δαγκωτός
δαιμονιακός δαιμονικός δαιμονιώδης δαιμονολατρικός δαιμονολογικός δαιμονομανής
δαιμονόληπτος δαιμονόπιστος δαιμονόπνευστος δαιμόνιος δακρυγόνος δακρυογόνος
δακρυόεις δακρυώδης δακρύβρεκτος δακρύβρεχτος δακτυλικός δακτυλιοειδής
δακτυλιόσχημος δακτυλογραφικός δακτυλόγραφος δαμαλίσιος δαμαλιώτικος
δαμασκηνής δαμασκηνός δανέζικος δανακιώτικος δανειακός δανεικός δανειοληπτικός
δανικός δαντελένιος δαντελλωτός δαντελωτός δαντικός δαπανηρός δασικός
δασκαλικός δασκαλοκεντρικός δασμοβίωτος δασμολογητέος δασμολογικός
δασοβιομηχανικός δασοκομικός δασολογικός δασονομικός δασοπονικός
δασοσκέπαστος δασοσκεπής δασωτός δασόβιος δασός δασόφυτος δασύθριξ δασύς
δασύφυλλος δασώδης δαφνηφόρος δαφνοστεφάνωτος δαφνοστεφής δαφνοστεφανωμένος
δαφνοφόρος δαχτυλιδένιος δαχτυλικός δαψιλής δείλαιος δεδομενοκεντρικός
δειγματοληπτικός δεικτικός δειλινός δειλός δειλόψυχος δεινός δεισιδαίμονας
δεισιδαιμονικός δειχτικός δεκάβαθμος δεκάγωνος δεκάδιπλος δεκάρικος δεκάτομος
δεκάχρονος δεκάωρος δεκαήμερος δεκαδικός δεκαεξαδικός δεκαεξασέλιδος
δεκαετής δεκαμελής δεκαμερής δεκαμηνιαίος δεκαοκτάχρονος δεκαοκταετής
δεκαπενθήμερος δεκαπενταετής δεκαπενταπλάσιος δεκαπεντασύλλαβος
δεκαπλάσιος δεκαπλός δεκατιαίος δεκατρείς δεκατρισύλλαβος δεκαψήφιος
δεκεμβριάτικος δεκεμβριανός δεκτικός δεκτός δελεαστικός δελταπτέρυγος
δελφικός δενδρικός δενδριτικός δενδροειδής δενδροκομικός δενδρόβιος δεντρικός
δεξής δεξιοτίμονος δεξιοτεχνικός δεξιός δεξιόστροφος δεοντικός δεοντολογικός
δερμάτινος δερματικός δερματολογικός δερματόδετος δερματώδης δεσμευτικός
δετικός δετός δευτερεύων δευτεριάτικος δευτεροβάθμιος δευτεροβαπτισμένος
δευτεροετής δευτεροκλασάτος δευτεροπαθής δευτερόκλιτος δευτερότοκος δεχτός
δηζελοκίνητος δηκτικός δηλητηριώδης δηλιακός δηλωτικός δημαγωγικός δημαρχιακός
δημευτικός δημιουργικός δημογραφικός δημοκοπικός δημοκρατικός δημοπρατικός
δημοσιογραφικός δημοσιολογικός δημοσιονομικός δημοσιοσχετιστικός
δημοσυνεταιριστικός δημοσυντήρητος δημοτικιστικός δημοτικός δημοφιλής
δημόσιος δημώδης διάβροχος διάδοχος διάκριτος διάλιθος διάμεσος διάνοικτος
διάπλατος διάπλοκος διάπυρος διάσημος διάσπαρτος διάστερος διάστικτος
διάτονος διάτορος διάτρητος διάττοντας διάφανος διάφεγγος διάφοροι διάφορος
διάχρυσος διάχυτος διήμερος διίστιος διαβαλκανικός διαβατάρικος διαβατήριος
διαβατός διαβεβαιωτικός διαβητικός διαβητολογικός διαβιβάσιμος διαβιβαστικός
διαβλητός διαβολεμένος διαβολικός διαβρογχικός διαβρωσιγενής διαβρωτικός
διαγαλακτικός διαγαλαξιακός διαγενεακός διαγνωστικός διαγραφείς διαγωνάλ
διαδερμικός διαδημοτικός διαδικαστικός διαδικτυακός διαδογματικός διαδοχικός
διαδριατικός διαεπαγγελματικός διαζευκτικός διαζευχτικός διαθέσιμος
διαθετικός διαθηκώος διαθλαστικός διαθρησκειακός διαθωρακικός διαιρέσιμος
διαιρετικός διαιρετός διαισθαντικός διαισθητικός διαιτητικός διαιώνιος διακαής
διακεκαυμένος διακεκομμένος διακηρυκτικός διακινήσιμος διακινητικός διακινητός
διακλαδικός διακοινοτικός διακομματικός διακονικός διακοσάρης διακοσιαπλάσιος
διακοσμητικός διακρίσιμος διακρανιακός διακρατικός διακριβωτέος διακριβωτικός
διακρυϊκός διακυβερνητικός διακός διακόσιοι διαλεκτικός διαλεκτός
διαλεχτός διαλλακτικός διαλλαχτικός διαλογικός διαλογιστικός διαλυτικός
διαλφαβητικός διαμάντινος διαμήκης διαμαντέ διαμαντένιος διαμαντοκόλλητος
διαμελιστικός διαμεσολαβητικός διαμεταγωγικός διαμετακομιστικός διαμετρικός
διαμονητήριος διαμορφωτής διαμορφωτικός διαμπερής διανεμητικός διανθής
διανοητός διανοουμενίστικος διανυσματικός διαπεραστικός διαπερατός
διαπιστωτικός διαπλανητικός διαπλαστικός διαπνευστικός διαπολιτισμικός
διαπραγματεύσιμος διαπρεπής διαπροσωπικός διαπρωκτικός διαπρύσιος διαπτικός
διαρθρωτικός διαρκής διαρρεύσας διαρρηκτός διαρροϊκός διαρρυθμιστικός
διασαφηνιστικός διασαφητικός διασκεδαστικός διασκεπτικός διασκευαστικός
διασταλτικός διασταλτός διαστατός διασταυρούμενος διαστημικός διαστολικός
διαστρικός διαστροφικός διαστρωματικός διασυμμαχικός διασυμπαντικός
διασυνδετικός διασυνοριακός διασφαλιστικός διασχίσιμος διασωθείς
διασωστικός διατακτικός διαταρακτικός διατεταρτημοριακός διατηρήσιμος
διατμητικός διατονικός διατρητικός διατροπικός διατροφικός διατυμπανισμένος
διαφανής διαφημιστικός διαφορίσιμος διαφορετικός διαφορικός διαφορτωτικός
διαφυλετικός διαφυλικός διαφωτιστικός διαφώτιστος διαχειριστικός διαχρονικός
διαχωρίσιμος διαχωριστικός διγενής διγλώχιν διδάξιμος διδακτέος διδακτικός
διδακτός διδασκαλικός διδαχτικός διεγέρσιμος διεγερτικός διεγχειρητικός
διεθνικός διεθνιστικός διεισδυτικός διεκδικήσιμος διεκδικητικός
διεμφυλικός διεμφυλικός διεξοδικός διεπαφικός διεπιστημονικός διεργεννοιακός
διερμηνευτικός διεστραμμένος διετής διευθετήσιμος διευθετημένος διευθυντικός
διευκρινιστικός διζυγωτικός διζυγώτης διζωνικός διηγηματικός διηθήσιμος
διηθητός διηλεκτρικός διηνεκής διηπειρωτικός διθέσιος διθυραμβικός διιστορικός
δικάσιμος δικάταρτος δικέφαλος δικαιικός δικαιοκρατικός δικαιοκρατούμενος
δικαιολογήσιμος δικαιολογητικός δικαιοπάροχος δικαιοπρακτικός δικαιωματικός
δικαστικός δικατάληκτος δικαϊκός δικηγορίστικος δικηγορικός δικινητήριος
δικομματικός δικονομικός δικοτυλήδονος δικτατορικός δικτυακός δικτυοκεντρικός
δικόρυφος δικότυλος διλεκτικός διλημματικός διμέτωπος διμελής διμερής
διμεταλλικός διμηνίτικος διμηνιαίος διογκωτικός διοικητικός διοικών
διολισθαίνων διονυσιακός διοπτρικός διοπτροφόρος διορατικός διοργανωτικός
διοριστήριος διουρηθρικός διουρητικός διοφθαλμικός διοχετεύσιμος διπλάσιος
διπλανός διπλοβάπτιστος διπλοβαπτισμένος διπλογραφικός διπλοκάρενος
διπλοπρόσωπος διπλοτρόπιδος διπλοφουρνιστός διπλωματικός διπλωματούχος
διπλός διπλότυπος διπλόφαρδος διπολικός διπρόσωπος διπτέρυγος διπυριτικός
δισέλιδος δισήμαντος δισδιάστατος δισθενής δισκογραφικός δισκόβαθμο δισμύριοι
διστακτικός δισταχτικός δισυπόστατος δισχίλιοι δισχιδής δισύλλαβος διτάξιος
διττός διυπουργικός διφασικός διφυής διφωσφορυλικός διφωσφορυλιούχος διχαλωτός
διχειλικός διχοτομικός διχρονίτικος διχτυωτός διψήφιος διψαλέος διωνυμικός
διώνυμος διώροφος δογματικός δοκησίσοφος δοκιμαστικός δολερός δολιχοκέφαλος
δομικός δομοκεντρικός δομοστοιχειωτός δονκιχωτιστής δοξαρωτός δοξαστικός
δοριάλωτος δορυφορικός δοσομετρικός δοτικός δοτός δουλεμπορικός δουλικός
δουλοπρεπής δουλωτικός δουλόπρεπος δουλόφρων δουνάβιος δούρειος δρακόντειος
δραματολογικός δραματουργικός δραστήριος δραστικός δραχμικός δραχμοβίωτος
δραχμολαγνικός δραχμοσυντήρητος δρεπανηφόρος δρεπανοειδής δρεπανοκυτταρικός
δριμύς δρομαίος δρομικός δροσάτος δροσερός δροσιστικός δρύινος δυαδικός
δυναμιτιστικός δυναμογόνος δυναμοηλεκτρικός δυναμωτικός δυναστευτικός
δυνατός δυνητικός δυσάλωτος δυσάρεστος δυσέλεγκτος δυσήκοος δυσήλατος δυσήλιος
δυσανάγνωστος δυσανάλογος δυσαναπλήρωτος δυσανεκτικός δυσαπόδεικτος
δυσαρίθμητος δυσαρμονικός δυσβάστακτος δυσβάσταχτος δυσγενής δυσδιάκριτος
δυσδιοίκητος δυσειδής δυσενδοκρινικός δυσεντερικός δυσεξάλειπτος δυσεξέλεγκτος
δυσεξίτηλος δυσεξιχνίαστος δυσεπίλυτος δυσεπίσχετος δυσεπίτευκτος
δυσεπιχείρητος δυσεπούλωτος δυσερμήνευτος δυσεφάρμοστος δυσεύρετος
δυσηχαγωγός δυσθεράπευτος δυσθερμαγωγός δυσθεώρητος δυσκίνητος δυσκατέργαστος
δυσκολοβάσταχτος δυσκολονόητος δυσκολοχώνευτος δυσκολόπιστος δυσκρασικός
δυσλεκτικός δυσλεξικός δυσμάσητος δυσμενής δυσμικός δυσνόητος δυσξήμβλητος
δυσπαράπλευστος δυσπερίγραπτος δυσπλασικός δυσπροσάρμοστος δυσπρόσβλητος
δυσπρόφερτος δυσπόρθητος δυστράχηλος δυστυχής δυσφασικός δυσφημιστικός
δυσφωτικός δυσχερής δυσώδης δυσώνυμος δυτικοευρωπαϊκός δυτικός δυτικότροπος
δυτικόφρων δυφιoστρεφής δυφιακός δυφιοδιαφανής δυϊκός δυϊστικός δωδεκάγωνος
δωδεκάκωπος δωδεκάλογος δωδεκάμηνος δωδεκάσκαλμος δωδεκάχρονος δωδεκάωρος
δωδεκαδάκτυλος δωδεκαδάχτυλος δωδεκαδακτυλικός δωδεκαδικός δωδεκαετής
δωδεκαμελής δωδεκανησιακός δωδεκαπλάσιος δωδεκαψήφιος δωδωναίος δωρικός
δόκιμος δόλιος δόλιος δύσβατος δύσερως δύσθυμος δύσκαμπτος δύσκολος δύσληπτος
δύσμορφος δύσνους δύσοσμος δύσπεπτος δύσπιστος δύσρευστος δύστηκτος δύστηνος
δύστροπος δύστυχος δύσχρηστος δύσχυμος εαρινός εβένινος εβαπορέ εβδομαδιάτικος
εβδομηκονταετής εβδομηντάχρονος εβραίικος εβραϊκός εγγαρίτικος εγγαστρίμυθος
εγγενής εγγλέζικος εγγράμματος εγγράψιμος εγγυητικός εγγύτατος εγγύτερος
εγερτικός εγκάθειρκτος εγκάθετος εγκάρδιος εγκάρσιος εγκαιροφλεγής
εγκαρδιωτικός εγκατεσπαρμένος εγκεφαλικός εγκεφαλολογικός εγκεφαλονωτιαίος
εγκληματογόνος εγκληματολογικός εγκλητικός εγκλιτικός εγκρατής εγκριτικός
εγκωμιαστικός εγκόλλητος εγκόσμιος εγκύκλιος εγχάρακτος εγχειρήσιμος
εγχειρητικός εγχρήματος εγχώριος εγωιστικός εγωκεντρικός εγωπαθής εδαφιαίος
εδαφοβελτιωτικός εδαφοκλιματικός εδαφολογικός εδαφοϋδατικός εδεμικός
εδικός εδραίος εδραιωτής εδώδιμος εθελοντικός εθελούσιος εθελόδουλος
εθιμικός εθιμοτυπικός εθιστικός εθναρχικός εθνεγερτικός εθνικιστικός
εθνικοσοσιαλιστικά εθνικοσοσιαλιστικός εθνικός εθνικόφρονας εθνικόφρων
εθνογραφικός εθνοκεντρικός εθνοκτόνος εθνολογικός εθνοπρεπής εθνοπρόβλητος
εθνοτικός εθνοφθόρος εθνοφοβικός εθνωφελής εθνόφοβος ειδεχθής ειδησεογραφικός
ειδητικός ειδικευμένος ειδικοποιημένος ειδικός ειδικότερος ειδοειδικός
ειδοποιητικός ειδοποιός ειδυλλιακός ειδωλολατρικός εικάζων εικαστικός
εικονιστικός εικονογραφικός εικονοκλαστικός εικονολατρικός εικονόφιλος
εικοσάχρονος εικοσαβάθμιος εικοσαετής εικοσαπλάσιος εικοσιτετράωρος
εικοτολογικός ειλητός ειλικρινής ειρηνευτικός ειρηνικός ειρηνιστικός
ειρηνοποιός ειρηνοφόρος ειρηνόφιλος ειρωνικός εισαγγελικός εισαγωγικός
εισακτέος εισηγητικός εισιτήριος εισοδηματικός εισπνευστικός εισπράξιμος
εισπρακτικός εισρέων εισροϊκός εκάτερος εκατοντάχρονος εκατονταβάθμιος
εκατονταπλάσιος εκατοστιαίος εκατοχρονίτικος εκατόχρονος εκβιαστικός
εκδηλωτικός εκδικητικός εκδοτικός εκδρομικός εκδόσιμος εκηβόλος εκθέσιμος
εκθειαστικός εκθεμελιωτικός εκθετικός εκθλιπτικός εκκαθαρισθής εκκαθαριστικός
εκκεντροφόρος εκκενωτικός εκκινητήριος εκκλησιαζόμενος εκκλησιαστικός
εκκολαπτικός εκκρεμής εκκριτικός εκκωφαντικός εκλέξιμος εκλαμπρότατος
εκλεκτικιστικός εκλεκτικός εκλεκτορικός εκλεκτός εκλεχτός εκλιπών
εκλογικός εκλογοαπολογιστικός εκλογοθηρικός εκλυτής εκλόγιμος εκμαυλιστικός
εκμεταλλεύσιμος εκμηδενιστικός εκμισθωτικός εκμυστηρευτικός εκνευριστικός
εκπέσιμος εκπαιδευτικός εκπεστέος εκπιέζω εκπιπτέος εκπληκτικός εκπνευστικός
εκπολιτιστικός εκπρόθεσμος εκπτωτικός εκρέων εκρήξιμος εκρηκτικός εκρηξιγενής
εκροϊκός εκστατικός εκστρατευτικός εκσυγχρονιστικός εκσφενδονισμένος εκτατήρας
εκτατός εκτελέσιμος εκτελεστικός εκτελεστός εκτελωνιστικός εκτενής εκτιμηθής
εκτιμητικός εκτονωτικός εκτοξευτικός εκτρωματικός εκτρωτικός εκτυπωτικός
εκτυφλωτικός εκφερικός εκφοβητικός εκφοβιστικός εκφορητικός εκφορτωτικός
εκφυλιστικός εκχιονιστικός εκχυδαϊστικός εκχωρητικός εκών ελάσιμος ελάσσων
ελάχιστος ελέγξιμος ελαιοαπωθητικός ελαιοκομικός ελαιουργικός ελαιοφοβικός
ελαιόφυτος ελαιώδης ελασμάτινος ελασματοειδής ελασματοποιήσιμος ελαστικός
ελαττωματικός ελατός ελαφένιος ελαφίσιος ελαφοειδής ελαφρούτσικος ελαφρυντικός
ελαφρόνους ελαφρός ελαφρύς ελαφρύτερος ελαϊκός ελβετικός ελεήμονας ελεήμων
ελεγειακός ελεγκάν ελεγκτικολογιστικός ελεγκτικός ελεεινός ελεημονητικός
ελεητικός ελεκτρίκ ελευθέριος ελευθεριάζων ελευθεριακός ελευθεριοκτόνος
ελευθεροποιός ελευθερόβουλος ελευθερόστομος ελευθερόφρων ελευσίνιος
ελεφάντινος ελεφαντένιος ελεύθερος ελεύτερος ελεών ελικοειδής ελικοφόρος
ελισαβετιανός ελιτίστικος ελιτιστικός ελκτικός ελκυστικός ελκώδης ελλαδικός
ελλανόδικος ελλειμματικός ελλειπτικός ελλειψοειδής ελληνικός ελληνιστικός
ελληνοκεντρικός ελληνομαθής ελληνοπρεπής ελληνορωμαϊκός ελληνοτουρκικός
ελληνόγλωσσος ελληνόκτητος ελληνόμορφος ελληνότροπος ελληνόφοβος ελληνόφωνος
ελλοβόκαρπος ελλογιμότατος ελλογιμώτατος ελλόγιμος ελονοσιακός ελουβιακός
ελπιδοφόρος ελπιστικός ελυτικός ελυτροειδής ελόβιος ελώδης εμαγιέ
εμβληματικός εμβολοφόρος εμβριθής εμβρυακός εμβρυογενής εμβρυοειδής
εμβρυολογικός εμβρυομητρικός εμβρυοφθόρος εμβρυϊκός εμβρυώδης εμβρόντητος
εμετικός εμετοκαθαρτικός εμετολογικός εμμανής εμμελής εμμηνοπαυσιακός
εμμονικός εμπαθής εμπαικτικός εμπειρικός εμπειροπόλεμος εμπερίστατος
εμπλουτιστικός εμπορευματικός εμπορεύσιμος εμπορικός εμποροκρατικός
εμπορορραπτικός εμποροϋπαλληλικός εμπράγματος εμπρεσιονιστικός εμπρηστικός
εμπροσθοβαρής εμπροσθογεμής εμπρόθεσμος εμπρόθετος εμπρόσθιος εμπόλεμος
εμφανέστατος εμφανής εμφανίσιμος εμφαντικός εμφατικός εμφυλιοπολεμικός
εμψυχωτικός ενάλιος ενάμισης ενάντιος ενάρετος ενάριθμος ενέγγυος ενέσιμος
ενήλιξ ενήμερος εναέριος εναίσιμος εναγής εναγώνιος εναλλάξιμος εναλλακτικός
ενανθρακωτικός εναντιωματικός εναντιόμορφος εναντιότροπος εναργές εναργής
εναρμονισμένος εναρμόνιος ενδαγγειακός ενδαυλικός ενδεής ενδεδυμένος
ενδεκασύλλαβος ενδελεχής ενδεχόμενος ενδημικός ενδημοεπιδημικός ενδιάθετος
ενδιαφέρων ενδικοφανής ενδοαγροτικός ενδοαορτικός ενδοαστρικός ενδοαυλικός
ενδογενής ενδογλωσσικός ενδοδαπέδιος ενδοδερμικός ενδοδιαδικαστικός
ενδοεθνικός ενδοεταιρικός ενδοημερήσιος ενδοηπατικός ενδοηπειρωτικός
ενδοθηλιακός ενδοθωρακικός ενδοιαστικός ενδοκαρδιακός ενδοκλαδικός
ενδοκοινοτικός ενδοκομματικός ενδοκράνιος ενδοκρανιακός ενδοκρατικός
ενδοκρινικός ενδοκρινολογικός ενδοκυβερνητικός ενδοκυττάριος ενδοκυτταρικός
ενδομυϊκός ενδονοσοκομειακός ενδοοικογενειακός ενδοομιλικός ενδοπεϊκός
ενδοσηραγγώδης ενδοσκοπικός ενδοστεφανιαίος ενδοσυνεδριακός ενδοσχολικός
ενδοτικός ενδοφθάλμιος ενδοφλέβιος ενδοφλεβικός ενδοχώριος ενδοϋαλοειδικός
ενδυναμωτικός ενδόμυχος ενδόσιμος ενδότατος ενδότερος ενδώτιος ενεδρευτικός
ενεργειακός ενεργητικός ενεργητισμός ενεργοβόρος ενεργοποιητικός ενεργός
ενετικός ενεχυρικός ενεχυροδανειστικός ενεχυρούχος ενεχόμενος ενεός ενζωοτικός
ενθαρρυντικός ενθετικός ενθουσιασμένος ενθουσιαστικός ενθουσιώδης
ενθρονιστικός ενθυμητικός ενιαίος ενιαύσιος ενιούσιος ενιστικός ενισχυτικός
εννεατής εννιάχρονος εννιακοσιοστός εννιακόσιοι εννιαψήφιος εννοιοκρατικός
εννοιόλεξο ενοικιαστήριος ενοικιοστασιακός ενοποιητικός ενοποιός ενορατικός
ενοχικός ενοχλητικός ενοχοποιητικός ενστικτώδης ενσυναίσθητος ενσυνείδητος
ενσύρματος ενσώματος εντάφιος ενταξιακός εντατικός ενταφιαστικός εντεκάχρονος
εντερικός εντεροπαθογόνος εντεταμένος εντεψίζικος εντομοαπωθητικός
εντομοκτόνος εντομολογικός εντομοφάγος εντοπίσιμος εντοπιστικός εντροπαλός
εντυπωσιακός εντυπωτικός εντόπιος ενυπόγραφος ενυπόθηκος ενυπόστατος ενωτικός
ενύπαρκτος ενύπνιος εξάγωνος εξάεδρος εξάκτινος εξάκωπος εξάμετρος εξάμηνος
εξάστηλος εξάστιχος εξάστυλος εξάτομος εξάχορδος εξάχρονος εξάωρος εξίτηλος
εξαίρετος εξαίσιος εξαγγελτήριος εξαγγελτικός εξαγνιστήριος εξαγνιστικός
εξαγριωτικός εξαγωγικός εξαγωγός εξαγωνικός εξαγώγιμος εξαδάκτυλος εξαδάχτυλος
εξαετής εξαιρέσιμος εξαιρετέος εξαιρετικός εξαιρετός εξακολουθητικός
εξακοσιοστός εξακριβωτικός εξακόσιοι εξακύλινδρος εξαλειπτικός εξαμβλωματικός
εξαμερής εξαμηνίτικος εξαμηνιαίος εξαναγκαστικός εξανθηματικός εξαντλητικός
εξαπλάσιος εξαπλός εξαργυρώσιμος εξαρθρωτικός εξαρτημένος εξαρτησιογόνος
εξασέλιδος εξασθενητικός εξασφαλιστικός εξατάξιος εξεζητημένος εξελίξιμος
εξελικτικός εξερευνητικός εξερχόμενος εξετασιοκεντρικός εξεταστέος
εξεταστικός εξευγενιστικός εξευμενιστικός εξευτελιστικός εξηγήσιμος εξηγητικός
εξηκονταετής εξηλασμένος εξημερωτικός εξημερώσιμος εξηντάχρονος εξηνταδικός
εξιδρωματικός εξιδρωτικός εξιλαστήριος εξιλεωτικός εξισορροπητικός εξισωτικός
εξοβελιστέος εξολισθητικός εξολοθρευτικός εξομοιωτικός εξομολογητικός
εξοντωτικός εξονυχιστικός εξοπλιστικός εξοργιστικός εξορκιστικός εξορμητικός
εξουθενωτικός εξουσιαστικός εξουσιομανής εξουσιοφρενής εξοφερικός εξοφλητέος
εξοχικός εξπρεσιονιστικός εξτρά εξτραβαγκάν εξτρεμαδουρικός εξτρεμιστικός
εξυγιαντικός εξυμνητικός εξυπηρετικός εξυπνακίστικος εξυπνότερος εξυψωτικός
εξωατμοσφαιρικός εξωγήινος εξωγενής εξωδιαδικαστικός εξωδικαστικός εξωεδαφικός
εξωθερμικός εξωθεσμικός εξωιδρυματικός εξωκοινοβουλευτικός εξωκομματικός
εξωκυττάριος εξωκυτταρικός εξωλέμβιος εξωλογικός εξωλογιστικός εξωμήτριος
εξωπολιτικός εξωπραγματικός εξωπυραμιδικός εξωραϊστικός εξωστικός εξωστρεφής
εξωσυστημικός εξωσχολικός εξωσωματικός εξωτερικός εξωτικός εξωφρενικός
εξόριστος εξόφθαλμος εξώγαμος εξώδικος εξώθερμος εξώλης εξώπροικος εξώτατος
εξώφτερνος εοκικός εορτάσιμος εορταστικός εορτινός επάκτιος επάλληλος επάξιος
επάργυρος επήκοος επίβουλος επίγειος επίγονος επίδικος επίδοξος επίζηλος
επίκαιρος επίκεντρος επίκληρος επίκοινος επίκουρος επίκτητος επίλεκτος
επίμαχος επίμεμπτος επίμονος επίμορτος επίμοχθος επίορκος επίπαστος επίπεδος
επίπλοκος επίπονος επίρραπτος επίσημος επίστεγος επίσωτρος επίτιμος επίτοκος
επίφθονος επίφοβος επίχαρις επίχριστος επίχρυσος επαίσχυντος επαγγελματικός
επαγγελτικός επαγωαναγωγικός επαγωγικός επαγωγός επαγώγιμος επαινετέος
επαινετός επακριβής επακτή επακτός επακόλουθος επαληθευτικός επαληθεύσιμος
επαναληπτικός επαναπατρίσιμος επαναστατικός επανασυσκευασμένος
επανορθωτικός επανορθώσιμος επανωτός επαρκής επαρχιακός επαρχικός επαρχιώτικος
επείγων επείσακτος επεισοδιακός επεκτάσιμος επεκτατικός επενδυμικός
επεξεργάσιμος επεξεργαστικός επεξηγηματικός επεξηγητικός επετειακός
επιβατήριος επιβατηγός επιβατικός επιβεβαιωτικός επιβλαβής επιβλητικός
επιβραδυντικός επιγενετικός επιγενόμενος επιγονατιδικός επιγραμματικός
επιγραφικός επιδέξιος επιδαπέδιος επιδεής επιδεικτικός επιδειξιμανής
επιδεκτικός επιδερμικός επιδημητικός επιδημικός επιδημιολογικός επιδιαιτητικός
επιδιορθώσιμος επιδοκιμαστικός επιδοματικός επιδοσιπαγής επιδραστικός
επιεικής επιζήμιος επιζήτητος επιζωοτικός επιθαλάσσιος επιθανάτιος επιθετικός
επιθηλιακός επιθυμητικός επιθυμητός επικήδειος επικίνδυνος επικαθείμενος
επικατάρατος επικατασκευαστικός επικερδέστερος επικερδής επικλινής
επικοινωνιακός επικολυρικός επικονιαστικός επικουρικός επικούρειος
επικρατής επικρατών επικρεμάμενος επικριτικός επικυρίαρχος επικυριαρχικός
επικυρώσιμος επικός επιλέξιμος επιλήνιος επιλήσμονας επιλήσμων επιλήψιμος
επιλεκτικός επιληπτικός επιλόχειος επιμήκης επιμελής επιμελητηριακός
επιμνημόσυνος επιμορφωτικός επινήιος επινίκιος επινεμητικός επινοητικός
επιπαγής επιπεδομετρικός επιπεδόκοιλος επιπεδόκυρτος επιπληκτικός επιπρόσθετος
επιπόλαιος επιρρεπής επιρρηματικός επισιτιστικός επισκέψιμος επισκευάσιμος
επισκληρίδιος επισκοπικός επισπεύδων επιστήθιος επιστημικός επιστημονικοφανής
επιστολικός επιστολογραφικός επιστρατευτικός επιστρεπτέος επισφαλής
επισχετικός επισωρευτικός επιτάφιος επιτήδειος επιτακτικός επιτατικός
επιτελής επιτελικός επιτευκτός επιτεύξιμος επιτιμητικός επιτραπέζιος
επιτρεπτός επιτροπικός επιτυχής επιτυχημένος επιτυχών επιτόπιος επιτύμβιος
επιφανειακός επιφανειοδραστικός επιφυλακτικός επιφωνηματικός επιχειρηματικός
επιχειρησιακός επιχρωματισμένος επιχώριος επιψευδαργυρωμένος εποικιστικός
επονείδιστος εποξειδικός εποξικός εποπτικός επουλωτικός επουλώσιμος επουράνιος
εποχιακός εποχικός επτάμηνος επτάστερος επτάστιχος επτάφωτος επτάωρος
επταετής επτακοσιοστός επτακόσιοι επταμελής επτανησιακός επταπλάσιος
επταψήφιος επωαστικός επωδικός επωφελής επόμενος επώδυνος επώνυμος εράσμιος
εραλδικός ερανικός ερανισματικός ερασιτεχνικός ερασμιακός ερατεινός εργάσιμος
εργασιακός εργασιομανής εργαστηριακός εργατικός εργατοϋπαλληλικός εργοδοτικός
εργολαβικός εργοληπτικός εργομετρικός εργονομικός εργοστασιακός εργώδης
ερεθισμένος ερεθιστικός ερειστικός ερευνητικός ερημικός ερημοδικήσας
εριστικός ερματιστός ερμαφρόδιτος ερμαϊκός ερμηνευτικός ερμηνευόμενος
ερμητικός ερπετοειδής ερπετομορφικός ερπετόμοφος ερπυστριοφόρος ερρωμένος
ερυθηματώδης ερυθροειδής ερυθροσταυρικός ερυθρωπός ερυθρόλαιμος ερυθρόλευκος
ερυθρός ερωτεύσιμος ερωτηματικός ερωτητικός ερωτιάρης ερωτιάρικος ερωτικός
ερωτοπονεμένος ερωτοχτυπημένος ερωτόληπτος ερώμενος εσθονικός εσκεμμένος
εσπεραντικός εσπερινός εστεμμένος εστιακός εσχατολογικός εσω-εξωλέμβιος
εσωκομματικός εσωλέμβιος εσωλογιστικός εσωστρεφής εσωτερικός εσώκλειστος
εσώτερος εσώψυχος ετήσιος εταιρικός εταστικός ετεροαναφορικός ετεροβίωτος
ετεροβιωμένος ετεροβιωματικός ετερογενής ετεροειδής ετεροθαλής ετεροκίνητος
ετερομήκης ετερομερής ετεροσκεδαστικός ετεροσωματικός ετεροφυλόφιλος
ετερόγλωσσος ετερόδοξος ετερόκεντρος ετερόκλητος ετερόκλιτος ετερόμορφος
ετερόπτωτος ετερόρρυθμος ετερόσημος ετερότοπος ετερότροφος ετερόφυλος
ετερόφωτος ετερόχθων ετερόχρονος ετερώνυμος ετησιοποιημένος ετοιματζήδικος
ετοιμοθάνατος ετοιμοπαράδοτος ετοιμοπόλεμος ετοιμόγεννος ετοιμόλογος
ετρουσκικός ετσιθελικός ετυμικός ετυμολογικός ευάερος ευάλωτος ευάρεστος
ευάρμοστος ευέλικτος ευέξαπτος ευήθης ευήκοος ευήλατος ευήλιος ευαίσθητος
ευαγγελικός ευανάγνωστος ευαπόδεικτος ευαπόκτητος ευβοϊκός ευγενέστερος
ευγενικός ευγνώμονας ευγνώμων ευδαίμων ευδαιμονικός ευδιάθετος ευδιάκριτος
ευδιαχώριστος ευδόκιμος ευειδής ευεξάλειπτος ευεξήγητος ευεπίδεκτος ευεπίφορος
ευερέθιστος ευεργετικός ευερμήνευτος ευετηριακός ευζωνικός ευηλεκτραγωγός
ευθαρσής ευθερμαγωγός ευθηνός ευθυμογραφικός ευθυμολογικός ευθυνόφοβος
ευθύβολος ευθύγραμμος ευθύς ευκίνητος ευκαιριακός ευκατάληπτος ευκατάστατος
ευκλεής ευκλείδειος ευκοίλιος ευκολοβάσταγος ευκολοδιάβαστος ευκολοδιάκριτος
ευκολονόητος ευκολοπλησίαστος ευκολοχώνευτος ευκολόπαρτος ευκολόπιστος
ευκρινής ευκτήριος ευκταίος ευλίμενος ευλαβής ευλαβητικός ευλαβικός
ευλογητός ευλογοφανής ευμάλακτος ευμαθής ευμαρής ευμεγέθης ευμενέστατος
ευμετάβλητος ευμετάβολος ευμετάδοτος ευμετάπειστος ευμεταχείριστος
ευνομούμενος ευνοϊκός ευνόητος ευξείνιος ευοίωνος ευπαθής ευπαρουσίαστος
ευπρεπής ευπροσάρμοστος ευπροσήγορος ευπρόσβλητος ευπρόσδεκτος ευπρόσδεχτος
ευπρόσωπος ευπόρθητος ευπώλητος ευρετικός ευρηματικός ευριπίδειος ευρυγώνιος
ευρυμαθής ευρυπρόσωπος ευρωβόρος ευρωενωσιακός ευρωζωνικός ευρωλιγούρης
ευρωσκεπτικιστικός ευρύς ευρύστερνος ευρύτερος ευρύχωρος ευσεβής ευσεβιστικός
ευσπλαχνικός ευσταθής ευσταλής ευσταχιανός ευστόμαχος ευσυγκίνητος
ευσχήμων ευσύνοπτος ευτελής ευτράπελος ευτραφής ευτυχής ευυπόληπτος
ευφημιστικός ευφλόγιστος ευφορικός ευφραδής ευφραντικός ευφρόσυνος ευφυέστατος
ευφωνικός ευφωτικός ευχάριστος ευχαριστήριος ευχείρωτος ευχερής ευχετήριος
ευχητήριος ευωδερός ευωδιαστός ευόφθαλμος ευώδης ευώνυμος εφάμιλλος εφέσιμος
εφήμερος εφίστιος εφαρμοστέος εφαρμοστικός εφαρμοστός εφαρμόσιμος εφεδρικός
εφεσίβλητος εφετζίδικος εφετικός εφετινός εφευρετικός εφηβικός εφησυχαστικός
εφιδρωτικός εφικτός εφοδιασμένος εφοδιαστικός εφοπλιστικός εφορευτικός
εφτάγερος εφτάδιπλος εφτάμηνος εφτάχορδος εφτάψυχος εφτάωρος εφταήμερος
εφτακόσιοι εφταμελής εφταμηνίτικος εφταπλάσιος εφταπλός εφτασύλλαβος εχέγγυος
εχέφρων εχθρικός εψεσινός εωθινός εωσφορικός εόρτιος εύανδρος εύβουλος
εύγλωττος εύγραμμος εύδιος εύδρομος εύηχος εύθετος εύθικτος εύθραυστος
εύθυμος εύκαιρος εύκαμπτος εύκολος εύκοσμος εύκρατος εύληπτος εύλογος εύμορφος
εύορκος εύοσμος εύπεπτος εύπιστος εύπλαστος εύπορος εύρυθμος εύρωστος εύσαρκος
εύσπλαγχνος εύσπλαχνος εύστοχος εύστροφος εύσχημος εύσωμος εύτακτος εύτηκτος
εύτονος εύτρωτος εύφημος εύφλεκτος εύφορος εύφωνος εύχαρις εύχρηστος εύχυμος
εὐάρεστος εὐρύπρωκτος εὐτράπελος ζάμπλουτος ζάπλουτος ζαβολιάρης ζαβός
ζαμπούνης ζαντός ζαρίφικος ζαρκαδίσιος ζαρομπασμένος ζαφειρένιος ζαχαράτος
ζαχαροζυμωμένος ζαχαροπλαστικός ζαχαρούχος ζαχαρωτός ζαχαρώδης ζείδωρος
ζεβλωμένος ζελατινώδης ζεματιστός ζεμπέκικος ζενδικός ζενιθιακός ζενιθικός
ζερβόδεξος ζερβός ζεστούτσικος ζεστός ζευγαρωτός ζευκτήριος ζευκτός ζευσικός
ζεύξιμος ζηλευτός ζηλιάρης ζηλότυπος ζηλόφθονος ζημιάρης ζημιογόνος ζημιωμένος
ζογκλερικός ζοριλίδικος ζορμπαλίδικος ζουγλός ζουμερός ζουμπουρλούδικος
ζοφερός ζοφώδης ζοχαδιακός ζούδιαρης ζούφιος ζυγοσταθμιστικός ζυγωματικός
ζυγός ζυμοειδής ζυμολογικός ζυμοτεχνικός ζυμωσιογόνος ζυμωτικός ζυμωτός
ζωγραφικός ζωγραφιστός ζωδιακός ζωεμπορικός ζωεμπόριο ζωηρός ζωηρόχρωμος
ζωνικός ζωντανός ζωογονητικός ζωογόνος ζωοδόχος ζωολατρικός ζωολογικός
ζωοποιός ζωοτεχνικός ζωοτόκος ζωοφοβικός ζωροαστρικός ζωστικός ζωτικός
ζωόφιλος ζωόφοβος ζωώδης ζόρικος ηβικός ηγγυημένος ηγεμονικός ηγετικός
ηδονικός ηδονιστικός ηδονοθηρικός ηδονόπληκτος ηδονόχαρος ηδυλόγος ηδυντικός
ηδύγλωσσος ηδύς ηδύφωνος ηδύφωτος ηθικοδιδακτικός ηθικοθρησκευτικός
ηθικοκρατικός ηθικολογικός ηθικοπλαστικός ηθικός ηθμοειδής ηθμώδης ηθογραφικός
ηθολογικός ηθοπλαστικός ηλίθιος ηλεκτραγωγός ηλεκτρεγερτικός ηλεκτρικός
ηλεκτροανατομικός ηλεκτροβόρος ηλεκτρογόνος ηλεκτροδυναμικός ηλεκτροκίνητος
ηλεκτρολυτικός ηλεκτρομαγνητικός ηλεκτρομηχανικός ηλεκτρομηχανολογικός
ηλεκτρονικός ηλεκτροπαραγωγικός ηλεκτροπαραγωγός ηλεκτροπτικός ηλεκτροστατικός
ηλεκτροφόρος ηλεκτροφώτιστος ηλεκτροχημικός ηλιακός ηλιθιώδης ηλιογέννητος
ηλιογραφικός ηλιοθερμικός ηλιοκαμένος ηλιοκεντρικός ηλιολατρικός ηλιοστεφής
ηλιοφώτιστος ηλιοψημένος ηλιόλουστος ηλιόμορφος ηλιόπληκτος ηλιόφιλος
ηλιόφωτος ηλιόχαρος ηλύσιος ημέτερος ημίγλυκος ημίγυμνος ημίδιπλος ημίκλαστος
ημίκλιντος ημίλευκος ημίμαυρος ημίπληκτος ημίρρευστος ημίσκληρος ημίτονος
ημίωρος ημαρτημένος ημεδαπός ημερήσιος ημερινός ημερολογιακός ημερομίσθιος
ημιάγριος ημιέτοιμος ημιαμφίδρομος ημιαναίσθητος ημιαυτόματος ημιβάρβαρος
ημιδιάφανος ημιδιανοιχθέν ημιδιαπερατός ημιδιαφανής ημιδιώροφος
ημιεπίσημος ημιεπαγγελματικός ημιθανής ημικρατικός ημικυκλικός ημικύκλιος
ημιμαθής ημιορεινός ημιπάρθενος ημιπαράλυτος ημιπαράφρων ημιπερατός
ημιπολύτιμος ημιπροεδρικός ημιρυμουλκούμενος ημισεληνοειδής ημισφαιρικός
ημιτελικός ημιυπόγειος ημιφάτνωτος ημιφανής ηπατικός ηπατολογικός ηπειρωτικός
ηπιότερος ηράκλειος ηρακλείτειος ηρακλειώτικος ηρεμιστικός ηρωικός ηρωινομανής
ησυχαστικός ηττοπαθής ηφαίστειος ηφαιστειακός ηφαιστειογενής ηφαιστειολογικός
ηχήεις ηχερός ηχηρός ηχητικός ηχοαπορροφητικός ηχοβολιστικός ηχοβόλος
ηχομετρικός ηχομιμητικός ηχομονωτικός ηχοποίητος ηχοφοβικός ηχόφοβος ηωζωικός
θέσμιος θήλυς θαθατζής θαλάσσιος θαλαμοειδής θαλαμωτός θαλασσής θαλασσαιμικός
θαλασσοβρεγμένος θαλασσοδερμένος θαλασσοφίλητος θαλασσόβρεχτος θαλασσόδαρτος
θαλασσόχρωμος θαλερός θαλλιούχος θαλπερός θαμαστός θαματουργός θαμβωτικός
θαμνοειδής θαμνοσκεπής θαμνόβιος θαμνόφυτος θαμνώδης θαμπερός θαμπωτικός
θανάσιμος θανατερός θανατηφόρος θανατικός θανών θαρραλέος θαρρετός θασίτικος
θαυμαστικός θαυμαστός θαυματουργικός θαυματουργός θαφτός θεάρεστος θείος
θεατρικός θεατρινίστικος θεατρομανής θεατρόφιλος θεατός θειαφένιος θειικός
θειούχος θειότατος θειώδης θεληματικός θελκτικός θελξίνοος θελξίνους
θεμέλιος θεματικός θεμελιακός θεμελιωτικός θεμελιώδης θεμιτός θεοβάδιστος
θεογέννητος θεογενής θεοδώρητος θεοειδής θεοκάπηλος θεοκατάρατος θεοκρατικός
θεολογικός θεομάχος θεομίσητος θεομητορικός θεονήστικος θεοπάλαβος
θεοσεβής θεοσκεπής θεοσκοτωμένος θεοσκότεινος θεοστεφής θεοτικός θεουργικός
θεοφίλητος θεοφιλέστατος θεοφιλής θεοφόρος θεοφύλακτος θεοφώτιστος θεράπων
θεραπεύσιμος θεριζοαλωνιστικός θερινός θεριστικός θερμαγωγός θερμαλιστικός
θερμαντικός θερμασμένος θερμιδικός θερμιδογόνος θερμιδομετρικός θερμικός
θερμιώτικος θερμογόνος θερμοδυναμικός θερμοηλεκτρικός θερμοκέφαλος
θερμομαγνητικός θερμομετρικός θερμομηχανικός θερμομονωτικός θερμοπυρηνικός
θερμοσκοπικός θερμοτηκόμενος θερμοτροπικός θερμουργός θερμοφιλικός
θερμοφόρος θερμοχρωματικός θερμόαιμος θερμός θερμόφιλος θερμόφοβος
θεσμικός θεσμοδίαιτος θεσπέσιος θεσπρωτικός θεσσαλικός θετικιστικός θετικός
θετός θεωρητικός θεϊκός θεϊστικός θεόγυμνος θεόκλειστος θεόκλητος θεόκουφος
θεόληπτος θεόμορφος θεόμουρλος θεόπεμπτος θεόπλαστος θεόπνευστος θεόρατος
θεόσταλτος θεόστενος θεόστραβος θεότρελος θεότυφλος θεόφτωχος θηβαίικος
θηλαίος θηλαστικός θηλοειδής θηλυγονικός θηλυκός θηλυμανής θηλυπρεπής θηραϊκός
θηρεύσιμος θηριόμορφος θηριώδης θιβετικός θλαστικός θλιβερός θλιπτικός
θνησιγενής θνησιμαίος θνητός θολερός θολοειδής θολοσκέπαστος θολοσκεπής
θολωτός θολός θοριούχος θορυβικός θορυβοποιός θορυβώδης θρήσκος θρακικός
θρασύδειλος θραψερός θρεπτικός θρεφτικός θρεψερός θρηνητικός θρηνώδης
θρησκευτικός θρησκευόμενος θρησκομανής θρησκοφοβικός θρησκόληπτος θρησκόφοβος
θριαμβικός θρομβολυτικός θρομβοστατικός θρομβώδης θρυλικός θρυπτικός
θυελλώδης θυλακοειδής θυμαρίσιος θυμελικός θυμικός θυμοειδής θυμοσοφικός
θυμωτσιάρης θυμόσοφος θυμώδης θυρεοειδής θυρεοτρόπος θυρσοφόρος θυσανοειδής
θυσανόμορφος θωπευτικός θωρακικός θωρακικός θωρακοσκοπικός θωρακοφόρος
θωρακωτός θωρηκτός ιάσιμος ιάσμινος ιαβέρειος ιαβαϊκός ιακωβιανός ιαματικός
ιαμβικός ιαπετικός ιαπωνικός ιατρικός ιατροβιολογικός ιατρογενής
ιατροκεντρικός ιατρομηχανολογικός ιατρονοσηλευτικός ιατροτεχνολογικός
ιατός ιβηρικός ιβοριανός ιβουάρ ιγμόρειος ιγνυακός ιδανικός ιδεακός ιδεαλίζων
ιδεατός ιδεογραφικός ιδεοκινητικός ιδεοκρατικός ιδεοληπτικός
ιδεολογικοπολιτικός ιδεολογικός ιδεοτυπικός ιδεώδης ιδιάζων ιδιαίτατος
ιδικός ιδιοδεκτικός ιδιοκατοίκητος ιδιοκτησιακός ιδιομεταλλικός ιδιοπαθής
ιδιοσυντήρητος ιδιοσύστατος ιδιοτελής ιδιοφυής ιδιωματικός ιδιωτικοοικονομικός
ιδιωφελής ιδιόβουλος ιδιόγραφος ιδιόκλιτος ιδιόκτητος ιδιόμελος ιδιόμορφος
ιδιότροπος ιδιότυπος ιδιόχειρος ιδιόχρωμος ιδιώνυμος ιδρυματικός ιδρυτικός
ιδρωτοποιός ιερακοειδές ιερακοειδής ιεραποστολικός ιεραρχικός ιερατικός
ιεροεξεταστικός ιεροκοκκυγικός ιεροκρατικός ιεροκτόνος ιερολογικός ιεροπρεπής
ιερουργικός ιερός ιερόσυλος ιεχωβικός ιεχωβιτικός ιζηματογενής ιζηματογόνος
ιησουιτικός ιθαγενής ιθυφαλλικός ιθύνων ιικός ικάριος ικανοποιητικός ικανός
ικετήριος ικετευτικός ικετικός ικτερικός ιλαροτραγικός ιλαρυντικός ιλαρός
ιλιγγιώδης ιλλυρικός ιλουστρασιόν ιλυγενής ιλυώδης ιμερτός ιμιτασιόν
ιμπρεσιονιστικός ινδιάνικος ινδικός ινδοευρωπαϊκός ινδονησιακός ινδουιστικός
ινιακός ινολυτικός ινοοπτικός ινοπυριτικός ινώδης ιξώδης ιοβόλος ιογενής
ιονοσφαιρικός ιοντικός ιοστεφής ιουδαϊκός ιουλιανός ιουνιανός ιουστινιάνειος
ιππαγωγός ιππευτικός ιππικός ιπποδρομιακός ιπποδρομικός ιπποκράτειος ιπποτικός
ιρακινός ιρανικός ιρασιοναλιστικός ιριδίζων ιριδικός ιριδιούχος ιριδωτός
ισάδελφος ισάξιος ισάριθμος ισανώμαλος ισαρχέγονος ισθμιακός ισκιερός
ισλαμιστικός ισλανδικός ισοβάθμιος ισοβαθής ισοβαρής ισογώνιος ισοδύναμος
ισοθερμικός ισοκυανικός ισοκόρυφος ισομήκης ισομεγέθης ισομερής ισομορφικός
ισοπαχής ισοπεδωτικός ισοπληθής ισορροπημένος ισορροπητικός ισοσθενής
ισοσταθμικός ισοστατικός ισοσύλλαβος ισοταχής ισοτελής ισοτονικός ισοφασικός
ισπανικός ισπανομαθής ισπανοτραφής ισπανόφωνος ισραηλινός ισραηλιτικός
ιστιοδρομικός ιστιοπλοϊκός ιστιοφόρος ιστολογικός ιστολυτικός
ιστορικός ιστοριογραφικός ιστοριοδιφικός ιστοριομετρικός ιστοχημικός
ισχιακός ισχιαλγικός ισχναντικός ισχνός ισχνόφωνος ισχυογενής ισχυρογνώμονας
ισχυρός ισχυρότερος ισόβαθμος ισόβαρος ισόβιος ισόθεος ισόθερμος ισόκυρος
ισόμετρος ισόμοιρος ισόμορφος ισόνομος ισόπαλος ισόπεδος ισόπλευρος ισόποσος
ισότιμος ισότονος ισόφωνος ισόχρονος ισόψηφος ιταλιάνικος ιταλικός ιταλομαθής
ιταλόφωνος ιταμός ιχθυηρός ιχθυοβόρος ιχθυογενετικός ιχθυοειδής ιχθυολογικός
ιχθυοτροφικός ιχθυοφάγος ιχθυόεις ιχθύμορφος ιχνηλάσιμος ιχνηλατήσιμος
ιχνογραφικός ιψενικός ιωαννιώτικος ιωδιούχος ιωνικός ιόνιος ιόχρους ιώβειος
ιώνιος κάγκανος κάθετος κάθιδρος κάθυγρος κάκιστος κάκοσμος κάλλιος κάλλιστος
κάρυνος κάτασπρος κάτισχνος κάτω κάτωχρος κέδρινος κέρινος κίβδηλος κίκινος
καίριος καβάφικος καβαλιστικός καβαλιώτικος καβαφικός καββαλιστικός
καβδιανός καβοντορίτικος καβουρδισμένος καβουρδιστός καβουρντισμένος
καβύλος καγκελωτός καγκελόφραχτος καδμείος καδοφόρος καζουιστικός καημενούλης
καθάριος καθήμενος καθαιρετικός καθαρευουσιάνικος καθαροδευτεριάτικος
καθαρτήριος καθαρτικός καθαρόαιμος καθαρός καθεδρικός καθεστωτικός καθηγητικός
καθημερνός καθησυχαστικός καθιερωτικός καθιστικός καθιστός καθοδηγητικός
καθολικός καθοριστικός καθυστερημένος καινοζωικός καινοπρεπής καινοτόμος
καινοφανής καινούργιος καινούριος καινός καινότροπος καιρικός καιροσκοπικός
κακάσχημος κακέκτυπος κακέμφατος κακαριστός κακεντρεχής κακοήθης
κακογέννητη κακογεννήτρα κακογράφος κακογραμμένος κακοδαίμων κακοδιάθετος
κακοδούλευτος κακοζώητος κακοθάλασσος κακοθάνατος κακοκαμωμένος κακολόγος
κακομαθημένος κακομοίρα κακομοίρης κακομοίρικος κακομοιρασμένος κακομοιρούλης
κακοντυμένος κακοξυσμένος κακοπίχερος κακοποιητικός κακοποιός κακοπράγμων
κακοπόδαρος κακορίζικος κακοσήμαδος κακοσούρης κακοστρωμένος κακοστόμαχος
κακοτράχαλος κακοχώνευτος κακτοειδής κακόβολος κακόβουλος κακόβραστος
κακόγλωσσος κακόγνωμος κακόγουστος κακόδοξος κακόζηλος κακόηχος κακόθυμος
κακόκεφος κακόλογος κακόμοιρος κακόμορφος κακόνομος κακόπιστος κακόπραγος
κακόσαρκος κακόσημος κακόστομος κακόσχημος κακότεχνος κακότροπος κακότυχος
κακόφωνος κακόχυμος κακόψυχος κακώνυμος καλάμινος καλαίσθητος καλαβρέζικος
καλαισθητικός καλαμένιος καλαματιανός καλαμοειδής καλαμοπόδαρος
καλαμποκένιος καλαμποκίσιος καλαμπόρτζος καλαμωτός καλαμώδης καλειδοσκοπικός
καλλίγραμμος καλλίκνημος καλλίκομος καλλίμορφος καλλίνικος καλλίπυγος
καλλίτερος καλλίφωνος καλλιγραφικός καλλιεπής καλλιεργήσιμος καλλιεργητικός
καλλιμάρμαρος καλλιπάρειος καλλιρροϊκός καλλιτεχνικός καλλωπιστικός καλοήθης
καλοβαλμένος καλογερίστικος καλογερικός καλογραμμένος καλοδιάθετος
καλοθάλασσος καλοθρεμμένος καλοκάγαθος καλοκαιριάτικος καλοκαιρινός
καλοκαρδιστικός καλολογικός καλομίλητος καλομαγειρεμένος καλομοίρης
καλοντυμένος καλοξυρισμένος καλοξυσμένος καλοπίχερος καλοπροαίρετος
καλορίζικος καλοστεκάμενος καλοστεκούμενος καλοσυνάτος καλοσχεδιασμένος
καλοτάξιδος καλοταϊσμένος καλοτυπωμένος καλοφορεμένος καλοφούρτουνος
καλοφόρετος καλούτσικος καλπαστικός καλπονοθευτικός καλπουζάνικος καλυβόσπιτο
καλυκοειδής καλυκοφόρος καλυμνιώτικος καλυπτήριος καλωδιακός καλόβολος
καλόβραστος καλόγεννος καλόγλωσσος καλόγνωμος καλόγουστος καλόδεχτος
καλόμοιρος καλόπιστος καλός καλόστρωτος καλότροπος καλότυχος καλόχυμος καλών
καμαρωτός καματερός καμηλίσιος καμινευτικός καμπίσιος καμπανιστός καμπανοειδής
καμπούρικος καμπριολέ καμπυλοειδής καμπυλωτός καμπυλόγραμμος καμπόσος καμπύλος
καναδέζικος καναδικός κανακεμένος καναρινής κανδηλανάπτης κανελής κανηφόρος
κανιστροειδής κανναβένιος κανονικός κανονισμένος κανονιστικός καντιανός
καουμπόικος καουτσουκένιος καπακωτός καπηλευτικός καπηλικός καπιταλιστικός
καπναγωγός καπνεργατικός καπνικός καπνιστικός καπνιστός καπνοβόρος καπνογόνος
καπούτ καπριτσιόζος καπριτσόζος καραβίσιος καραγκιόζικος καραγκούνικος
καραμπινάτος καραφλός καραϊβικός καρβονικός καρβουνιάρικος καρδιαγγειακός
καρδιοαναπνευστικός καρδιογραφικός καρδιοειδής καρδιολογικός καρδιοπνευμονικός
καρδιοχειρουργικός καρδιτσιώτικος καρδιόσχημος καρκινιάρης καρκινικός
καρκινοειδής καρκινολυτικός καρκινοπαθής καρκινωματώδης καρκινώδης καρλής
καρμίρικος καρναβαλίστικος καρναβαλικός καρντέ καροτής καρπερός καρπιαίος
καρποφόρος καρσινός καρστικός καρτερικός καρτεσιανός καρτοκινητός
καρυδάτος καρυδένιος καρφωτός καρχηδονιακός καρχηδονικός καρωτικός κασιδιάρης
κασμιρικός κασσιτέρινος καστανέρυθρος καστανομάλλης καστανόξανθος καστανός
καστόρι καστόρινος κατάβρεκτος κατάδηλος κατάδρομος κατάθαμβος κατάκλειστος
κατάκοπος κατάκορφος κατάκρυος κατάλευκος κατάλληλος κατάλοιπος κατάμαυρος
κατάμονος κατάντης κατάξανθος κατάξερος κατάξηρος κατάπικρος κατάπληκτος
κατάπλωρος κατάπρυμος κατάπτυστος κατάρατος κατάρρυτος κατάσκιος κατάσπαρτος
κατάστερος κατάστικτος κατάστιχτος κατάφορτος κατάφρακτος κατάφυτος κατάφωρος
κατάχλομος καταβλητικός καταγάλανος καταγέλαστος καταγγελτικός καταγραφικός
καταδεχτικός καταδικάσιμος καταδικαστέος καταδικαστικός καταδικός
καταδιωκτικός καταδιωχτικός καταδολιευτικός καταδρομικός καταδυναστευτικός
καταθετικός καταθλιπτικός καταιγιδοφόρος καταιγιστικός κατακίτρινος
κατακαίνουριος κατακαημένος κατακλυσμιαίος κατακλυσμικός κατακριτέος
κατακόκκινος κατακόρυφος καταλανικός καταληκτικός καταληπτικός καταληπτός
καταλογιστός καταλυτικός καταμήνιος καταμαγεύω καταμόναχος καταναγκαστικός
κατανεμητέος κατανοητός κατανυκτικός κατανυχτικός καταπειστικός καταπιεστικός
καταπληχτικός καταποδιαστός καταπονητικός καταπράσινος καταπραϋντικός
καταραμένος καταρρακτώδης καταρροϊκός κατασβεστικός κατασκέπαστος
κατασκοπευτικός κατασκότεινος κατασταλακτός κατασταλαχτός κατασταλτικός
καταστρεπτικός καταστροφικός κατασχέσιμος κατασχετήριος κατασχετός
κατατεθείς κατατονικός κατατοπιστικός κατατυραννικός καταφανής καταφατικός
καταφώτιστος καταχαρούμενος καταχθόνιος καταχρηστικός καταχτητικός
καταψυκτικός κατεβατός κατεδαφιστικός κατεργάρης κατεργάρικος κατεργάσιμος
κατερχόμενος κατευθυντήριος κατευναστικός κατεχόμενος κατηγορηματικός
κατηγορικός κατηφής κατηφορικός κατηχητήριος κατηχητικός κατιονικός
κατοικίδιος κατοπινός κατοπτευτικός κατοπτρικός κατορθωτός κατουρλιάρης
κατοχυρωτικός κατσανάτος κατσαρομάλλης κατσαρωτός κατσαρός κατσικίσιος
κατσικοπόδαρος κατσικοπόδης κατσούφης κατσούφικος κατωφερής κατόχρονος
κατώτερος καυδιανός καυκάσιος καυλιάρης καυλιάρικος καυλόσχημος καυστικός
καυτός καυχησιάρης καυχησιάρικος καφέ καφασωτός καφεδής καφενόβιος καφετής
καφεϊνούχος καφκικός καχεκτικός καχύποπτος καψαλιστός καψερός καψοκαλύβας
καύσιμος κβαντικός κβαντοδυναμικός κβαντοδυφιακός κβαντομηχανικός
κειμενικός κεκαθαρμένος κεκαλυμμένος κεκηρυγμένος κεκλιμένος κεκοιμημένος
κελτικός κεντητός κεντρικοποιημένος κεντρικός κεντροαριστερός κεντροβαρής
κεντρομόλος κεντροφιλελεύθερος κεντροφόρος κεντρόφυγος κεντρόφυξ κεντρώος
κενός κενόσοφος κενόσπουδος κεράδικο κεράτινος κερένιος κεραμιδής κεραμιδωτός
κεραμιώτικος κεραμοσκεπής κεραμωτός κερασένιος κερασής κερασφόρος κερατένιος
κεραυνοβόλος κεραυνόπληκτος κεραύνιος κερδομανής κερδοσκοπικός κερδοφόρος
κερκοειδής κερκοφόρος κερκυραίικος κερκυραϊκός κεφάτος κεφαλίσιος κεφαλαίος
κεφαλαιοκρατικός κεφαλαιοποιηθείς κεφαλαιοποιητικός κεφαλαιουχικός κεφαλαιώδης
κεφαλικός κεφαλληνιακός κεφαλλονίτικος κεφαλομετρικός κεχηνώς κεχριμπαρένιος
κηδεμονικός κηδευτικός κηκογόνος κηπευτικός κηπευτός κηπεύσιμος κηπουρικός
κηροπλαστικός κηρωτός κηρώδης κητοειδής κιβωτιοφόρος κιβωτιόσχημος κιβωτοειδής
κιναισθητικός κινδυνολογικός κινδυνώδης κινεζικός κινηματική κινηματογραφικός
κινησιοθεραπευτικός κινητήριος κινητικός κινητός κιονίτης κιονοειδής κιρκάδιος
κιρκαδιανός κιρκαδικός κιρρωτικός κιρσώδης κισσοστεφής κιτρικός κιτρινιάρης
κιτρινόμαυρος κιτρινόφαιος κιτρινόχρους κιτς κιτσαριό κιτσοβόγκ κλέφτικος
κλαδευτικός κλαδικός κλαδωτός κλανιάρης κλαρωτός κλασικός κλασματικός
κλαυτός κλαψιάρης κλαψιάρικος κλειδωτός κλεινός κλεις κλειστός κλειτοριδικός
κλεπτώνυμος κλεφτός κλεψίγαμος κλεψίτυπος κλεψιμαίικος κλημάτινος κληματένιος
κληρονομικός κληρονομούμενος κληρωσάμενος κληρωτός κλητήριος κλητικός κλητός
κλιμακοποιημένος κλιμακοφόρος κλιμακτηρικός κλιμακωτός κλιματικός
κλιματολογικός κλινήρης κλινικός κλιτικός κλιτός κλοπιμαίος κλούβιος κλωστικός
κλωστοϋφαντουργικός κνημαίος κνημιαίος κοίλος κογχοειδής κοζάκικος κοζανίτικος
κοιλιακός κοιλιόδουλος κοιλόκυρτος κοιμήσης κοιμήσικος κοιμητηριακός
κοινοβιακός κοινοβουλευτικός κοινολεκτικός κοινοπρακτικός κοινοσυντήρητος
κοινωνιακός κοινωνικοασφαλιστικός κοινωνικοεπαγγελματικός κοινωνικοοικονομικός
κοινωνικοπολιτικός κοινωνικοπολιτιστικός κοινωνικοπρακτικός κοινωνικός
κοινωνιολογικός κοινωνιονομικός κοινωφελής κοινός κοινότοπος κοινότυπος
κοιταματολογικός κοκάλινος κοκέτης κοκαλένιος κοκαλιάρης κοκαϊνομανής
κοκκινομάλλης κοκκινοτρίχης κοκκινωπός κοκκιώδης κοκκολιθοφόρος κοκκομετρικός
κοκκυγικός κοκκώδης κοκορόμυαλος κολάσιμος κολακευτικός κολασμένος κολεγιακός
κολλητικός κολλητός κολλοειδής κολλώδης κολοβός κολοκυθένιος κολονάτος
κολπατζίδικος κολπικός κολποειδής κολποκοιλιακός κολυμβητικός κολυμπητός
κομματιαστός κομματικός κομμουνιστικός κομμωτικός κομουνιστικός κομπαστικός
κομπλέ κομπλεξικός κομπλιμεντόζος κομπογιαννίτικος κομπορρήμων
κομφορμιστικός κομψευόμενος κομψοεπής κομψός κονδυλοφόρος κονδυλώδης
κονισαλέος κοντακιανός κοντινός κοντοκουρεμένος κοντομάνικος κοντοπίθαρος
κοντοφάρδουλος κοντοχωριανός κοντούλης κοντούτσικος κοντυλένιος
κοντόθωρος κοντόκαννος κοντόμερος κοντόμυαλος κοντόουρος κοντόπαχος κοντόπνοος
κοντότερος κοντόφθαλμος κοντόχοντρος κοντόχρονος κοντύτερος κοπαδιάρης
κοπαδιαστός κοπανιστός κοπιαστικός κοπιώδης κοπρολάγνος κοπροφάγος κοπτερός
κοράλλινος κορακάτος κορακοζώητος κοραλλένιος κοραλλιογενής κοραλλιοειδής
κορδωτός κορεατικός κορινθιακός κοριτσίστικος κοροϊδίστικος κοροϊδευτικός
κορτιζονούχος κορτικοειδής κορυβαντικός κορυνηφόρος κορυφαίος κορφιάτικος
κορωπιώτικος κοσμαγάπητος κοσμηματογραφικός κοσμητικός κοσμικός κοσμιότατος
κοσμοβριθής κοσμογονικός κοσμογραφικός κοσμογυρισμένος κοσμοζωικός
κοσμοκρατορικός κοσμολογικός κοσμοξάκουστος κοσμοπολίτικος κοσμοπολιτικός
κοσμοσωτήριος κοσμοϊστορικός κοστοβόρος κοτίσιος κοτζάμ κοτσανάτος κοτσονάτος
κουκλίστικος κουκλοθεατρικός κουκουλάρικος κουλοχέρης κουλτουριάρης
κουλός κουμανταδόρικος κουμπωτός κουνιστός κουραστικός κουρδικός κουρδιστός
κουρελής κουρελιάρης κουρευτικός κουρλός κουρμπαριστός κουρουπιαστός κουρού
κουσελιάρης κουστουμαρισμένος κουτοπόνηρος κουτούτσικος κουτρούλης
κουτσαβάκικος κουτσοβλαχικός κουτσομπολίστικος κουτσομπόλικος κουτσονούρης
κουτσοχέρης κουτσός κουτός κουφικός κουφιοκέφαλος κουφονησιώτικος κουφωτός
κουφόνους κουφός κοφτερός κοφτός κοχλιαίος κοχλιακός κοχλιοειδής κοχλιοφόρος
κούτσικος κούφιος κούφος κράτιστος κρίθινος κρίσιμος κραδαστικός κρανένιος
κρανιδιώτικος κρανιοεγκεφαλικός κρανιολογικός κρανιομετρικός κρανιοπροσωπικός
κρανοειδής κρανοφόρος κρασάτος κραταιός κρατερός κρατικοδίαιτος
κρατικός κρατοκεντρικός κραυγαλέος κρεάτινος κρείσσων κρεατής κρεατερός
κρεατωμένος κρεμανταλάδικος κρεμαστός κρεμεζής κρεμώδης κρεοφάγος κρημνώδης
κρητιδικός κρητιδικός κρητικός κριθαρένιος κριθαρίσιος κρικοειδής κρικωτός
κρινένιος κρινοδάκτυλος κρινοδάχτυλος κρινοειδής κρινόλευκος κρισογόνος
κριόμορφος κροατικός κροκάτος κροκαλοπαγής κροκοβαφής κροκοδείλιος
κροκοειδής κροκωτός κροσσάρω κροσσωτός κροταφιαίος κροταφικός κροταφογναθικός
κρουσιφλεγής κρουσταλλένιος κρουστικός κρουστός κρυερός κρυμμένος κρυοσκοπικός
κρυοσυντηρημένος κρυούτσικος κρυπτογαμικός κρυπτογραφικός κρυπτολογικός
κρυστάλλινος κρυσταλλένιος κρυσταλλικός κρυσταλλογραφικός κρυσταλλοειδής
κρυσταλλώδης κρυφτός κρυφός κρυψίβουλος κρυψίγαμος κρυψίνους κρυόμπλαστος
κρόκινος κρόνιος κρύος κρύφιος κτηματικός κτηματοκεντρικός κτηματομεσιτικός
κτηνοτροφικός κτηνοφοβικός κτηνόμορφος κτηνώδης κτηριακός κτηριολογικός
κτητορικός κτιριακός κτιστός κτιτορικός κτυπητός κυανωπός κυανόλευκος κυανός
κυβερνήσιμος κυβερνητικός κυβερνοαναζητήσιμος κυβικός κυβιστικός κυβοειδής
κυκλαδίτικος κυκλαδικός κυκλικός κυκλοειδής κυκλοθυμικός κυκλοπυριτικός
κυκλοφοριακός κυκλοφορικός κυκλωνικός κυκλωτικός κυκλόσχημος κυκλώπειος
κυλινδροειδής κυλινδρωτός κυλιστός κυλιόμενος κυλλός κυματικός κυματιστός
κυματογόνος κυματοειδής κυματώδης κυνηγάρης κυνηγετικός κυνηγιάρικος κυνικός
κυπαρίσσινος κυπαρίσσινος κυπαρισσένιος κυπελλοειδής κυπελλούχος κυπελλόσχημος
κυπραίικος κυπραίος κυπριακός κυπριώτικος κυρίαρχος κυρηναϊκός κυριακάτικος
κυριαρχικός κυριλέ κυριλλικός κυριολεκτικός κυρτός κυρωτικός κυστεοκολπικός
κυστικός κυστοειδής κυτοπλασματικός κυτταρικός κυτταρογόνος κυτταροειδής
κυτταρολυτικός κυτταροπλασματικός κυτταροστατικός κυφωτικός κυφός κυψελοειδής
κωδωνοειδής κωλοπετσωμένος κωλόφαρδος κωματώδης κωμιακίτικος κωμικοτραγικός
κωνικός κωνοειδής κωνοφόρος κωπήλατος κωπήρης κωπηλατικός κωφάλαλος κωφός
κόκκινος κόλουρος κόμοδος κόσμιος κύκλιος κύκνειος κύριος κώος κώτικος λάβρος
λάγνος λάιτ λάλος λάσκος λέσβιος λίγος λίθινος λίμπερο λίχνος λαίμαργος
λαβυρινθώδης λαγαρός λαγωχειλικός λαγόκαρδος λαγόνιος λαδής λαδί λαδερός
λαθρεμπορικός λαθρόβιος λαθρόγαμος λαιλαπώδης λαιμικός λακανικός λακαρισμένος
λακωνικός λαλίστατος λαλητός λαμαρινένιος λαμιακός λαμιώτικος λαμπαδηφόρος
λαμπερός λαμπριάτικος λαμπροφόρος λαμπρός λαμπρόφωνος λαξευτός λαογραφικός
λαοκρατικός λαομίσητος λαοπρόβλητος λαοσωτήριος λαοφίλητος λαοφιλής
λαπλασιανός λαρισαϊκός λαρυγγικός λαρυγγολογικός λαρυγγόφωνος λασιθιώτικος
λασπολόγος λασπώδης λαστιχένιος λατεριτικός λατινικός λατινοαμερικανικός
λατινογραφημένος λατινοπρεπής λατομικός λατρευτικός λατρευτός λαφρύς λαχανί
λαχταριστός λαϊκίστικος λαϊκιστικός λαϊκός λαϊκότροπος λείος λεβέντικος
λεβεντόκορμος λεγκάτο λειαντικός λειμώνιος λειπανάβατος λειράτος λειτουργικός
λειχηνοειδής λειχηνόμορφος λειχούδης λειψανάβατος λειψερός λειψός λεκανοειδής
λεκτικός λεμβουχικός λεμονάτος λεμονής λεμφαδενικός λεμφατικός λεμφικός
λεμφοκυτογόνος λεμφοκυτταρικός λεμφοφόρος λενινιστικός λεξαριθμικός
λεξικολογικός λεξικός λεξιλογικός λεοντόθυμος λεοντόκαρδος λεοντόμορφος
λεπιδοφόρος λεπιδωτός λεπιδόσχημος λεπρωτικός λεπρός λεπταίσθητος
λεπτοδουλεμένος λεπτοκαμωμένος λεπτοκυρτωτός λεπτολογικός λεπτολόγος
λεπτομερής λεπτομερειακός λεπτοτεχνικός λεπτοφυής λεπτούτσικος λεπτόγαιος
λεπτόκοκκος λεπτόκυρτος λεπτόπαχος λεπτόρρευστος λεπτός λεπτόσωμος λεπτότεχνος
λεπτόφωνος λεπτύκυρτος λερναίος λερός λεσβιακός λεττονικός λευκαδίτικος
λευκαντικός λευκαυγής λευκοκυτταρικός λευκοντυμένος λευκοπυρώμενος
λευκορωσικός λευκοσιδηρούς λευκοφορεμένος λευκοφόρος λευκωματικός
λευκωματούχος λευκωματώδης λευκός λευκός λευκόφαιος λευκόχρους λευτικός
λευχείμων λεωνιδιώτικος λεωφορειακός λεόντειος λεύκινος λεύτερος ληθαργικός
ληξιαρχικός ληξιπρόθεσμος ληξουριώτικος λησμονιάρης ληστευμένος ληστρικός
λιανικός λιανός λιαστός λιβαδίσιος λιβαδικός λιβανικός λιβανωτός λιβιδινικός
λιγδερός λιγδιάρης λιγδιάρικος λιγνιτοφόρος λιγνός λιγοήμερος λιγοζώητος
λιγοσέλιδος λιγοστός λιγουρευτός λιγούρης λιγυρός λιγυρόφωνος λιγωμένος
λιγόλεπτος λιγόλογος λιγόπιστος λιγότερος λιγόφαγος λιγόχρονος λιγόψυχος
λιθαγωγός λιθανθρακοφόρος λιθογλυφικός λιθογραφικός λιθογόνος λιθοδομικός
λιθοκόλλητος λιθομετέωρος λιθομετεωριτικός λιθοσφαιρικός λιθοτομικός λιθοτόμος
λιθόβλητος λιθόδμητος λιθόκτιστος λιθόστρωτος λιθόχτιστος λικνιστικός λιλά
λιμάρης λιμάρικος λιμενικός λιμενοβιομηχανικός λιμνίσιος λιμναίος λιμνόβιος
λιμπιστικός λιμώδης λινομέταξος λινοτυπικός λινόδετος λινός λινόχρους λιξούρης
λιονταρόψυχος λιοπερίχυτη λιπανάβατος λιπαντικός λιπαρός λιπιδαιμικός
λιποδιαλυτός λιποειδής λιποθυμικός λιπόβαρος λιπόθυμος λιπόσαρκος λιπόψυχος
λιτοδίαιτος λιτός λιχουδιάρης λιχουδιάρικος λιχούδης λιχούδικος λιόκαλος
λιόχαρος λογαριθμικός λογικοφανής λογικός λογισθείς λογιστικός λογιότατος
λογογραφικός λογοκρατικός λογοκριτικός λογοτεχνικός λογχοειδής λογχοφόρος
λοιμικός λοιμογόνος λοιμωξιολογικός λοιμό λοιμώδης λοιπός λονδρέζικος
λοξός λουδοβίκειος λουθηρανικός λουθηρανός λουκούλλειος λουλακάτος λουλακής
λουλουδένιος λουλουδιστά λουλουδιστός λουλούδινος λουξ λουριδωτός λουσάτος
λουόμενος λοφώδης λούγκο λούμπεν λούτος λούτρινος λυγερόκορμος λυγερός
λυγμικός λυγουριώτικος λυδικός λυκόμορφος λυμφατικός λυπηρός λυπητερός
λυρικός λυσίκομος λυσίπονος λυσιγόνος λυσιτελής λυσσάρης λυσσάρικος λυσσαλέος
λυσσιάρικος λυσσόδηκτος λυσσώδης λυτρωτικός λυτρώσιμος λυτός λωβιάρης λωλός
λωτοφάγος λόγιος λύγινος λύγκειος λύδιος μάγκικος μάλλινος μάξι μάταιος
μέγας μέγιστος μέλαινα μέλας μέλινος μέλλων μέσα μέσος μέτριος μήλειος μήλινος
μίνι μίσανδρος μίσθαρνος μίσθιος μαβής μαγγανευτικός μαγγανιούχος μαγειρευτός
μαγευτικός μαγιάτικος μαγικός μαγκούφης μαγματικός μαγματογενής μαγνησιούχος
μαγνητογυρικός μαγνητοηλεκτρικός μαγνητοθερμικός μαγνητοστατικός μαδαροκέφαλος
μαζικός μαζοχιστικός μαζωχτός μαθηματικός μαθησιακός μαθητευόμενος μαθητικός
μαιάνδριος μαιανδρικός μαιευτικός μαιονίδης μακάβριος μακάριος μακαρίτης
μακαριστός μακεδονίτικος μακεδονικός μακιαβελικός μακραίων μακραίωνος μακρινός
μακροβίοτος μακροκάνης μακροκατάληκτος μακροκοσμικός μακρολαίμης μακρολόγος
μακρομάλλης μακρομαλλούσα μακρομοριακός μακροοικονομικός μακροπρόθεσμος
μακροπόδαρος μακροσκελής μακροσκοπικός μακρουλός μακροχέρης μακροχρόνιος
μακρυμάνικος μακρόβιος μακρόθυμος μακρόινος μακρόπνοος μακρόπνους μακρόπους
μακρόστενος μακρόσυρτος μακρόφωνος μακρόχειρ μακρόχρονος μακρύκαννος
μακρύς μακρύτερος μακό μαλακισμένος μαλακοτρίφτης μαλακούτσικος μαλακτικός
μαλαματένιος μαλαχτικός μαλαϊκός μαλγασικός μαλθακός μαλλιαρός μαλλοβάμβακος
μαλλομέταξος μαλλωτός μαλτέζικος μαμμόθρεπτος μαμμόθρεφτος μαμούχαλος μανάτος
μανδαλωτός μανιάτικος μανιακός μανικός μανιοκαταθλιπτικός μανιχαϊκός μανιώδης
μαντευτικός μαντζουριανός μαντηλοφόρος μαντικός μανός μαξιμαλιστικός
μαοϊκός μαραγκούδικο μαραζιάρης μαραζιάρικος μαραθώνιος μαρασμώδης
μαργαριτοφόρος μαργαρώδης μαργιόλης μαργιόλικος μαρινάτος μαρκέ μαρμάρινος
μαρμαροειδής μαρμαρυγιακός μαρμαρόστρωτος μαρξιστικός μαροκινός μαρουσιώτικος
μαρτιάτικος μαρτυριάρης μαρτυριάρικος μαρτυρικός μασητήριος μασκέ μασκοφόρος
μαστιγοφόρος μαστιγωτικός μαστικός μαστιχοφόρος μαστοειδής μαστορικός
μαστούρης μαστροδούλεφτος μασχαλιαίος ματ ματαβιβάσιμος ματαιόδοξος
ματαιόφρονας ματαιόφρων ματαριστικός ματεριαλιστικός ματζόβολος ματζόρε ματσό
μαυριτανικός μαυρογάλανος μαυρογένης μαυροκίτρινος μαυρομάλλης μαυρομάνικος
μαυροντυμένος μαυροφορεμένος μαυροφόρος μαφιόζικος μαχητικός μαχητός
μαϊμουδίσιος μαϊμουδίστικος μαύρος μείζων μείζων μείων μεγάθυμος μεγάλος
μεγάτιμος μεγακέφαλος μεγαλειώδης μεγαλεπήβολος μεγαλιθικός μεγαλοαστικός
μεγαλογράμματος μεγαλοδύναμος μεγαλοκαμωμένος μεγαλομάτης μεγαλομανής
μεγαλοπαρασκευιάτικος μεγαλοπράγμων μεγαλοπρεπής μεγαλορρήμων μεγαλοσχήμων
μεγαλοφάνταστος μεγαλοφυής μεγαλοϊδεάτικος μεγαλοϊδεατικός μεγαλούτσικος
μεγαλόθυμος μεγαλόκαρδος μεγαλόπνευστος μεγαλόπρεπος μεγαλόστομος μεγαλόσχημος
μεγαλόφθαλμος μεγαλόφρων μεγαλόφωνος μεγαλόψυχος μεγαλύτερος μεγαλώνυμος
μεγαρίτικος μεγεθικός μεγεθυντικός μεζεκλήδικος μεζεκλίδικος μεθανίτικος
μεθεπόμενος μεθευρετικός μεθεόρτιος μεθοδευτικός μεθοδικός μεθοδολογικός
μεθυλικός μεθυστικός μεθόριος μεικτός μειλίχιος μειοδοτικός μειονεκτικός
μειχτός μειωτέος μειωτικός μειόκαινος μελάγχρους μελάτος μελένιος μελής
μελίφθογγος μελίχρυσος μελαγχολικός μελαγχρωστικός μελαμψός μελανίτικος
μελανηφόρος μελανωπός μελανόδερμος μελανόμορφος μελανός μελανόφθαλμος
μελαψός μελετηρός μελετητικός μελικός μελισσοκομικός μελισσοτροφικός
μελιστάλακτος μελιστάλαχτος μελιταίος μελιτζανής μελιτοφόρος μελιτόχρους
μελιχρός μελλοθάνατος μελλοντικός μελλούμενος μελοδραματικός μελωδικός μελό
μεμπτός μεμψίμοιρος μενεξεδένιος μενεξεδής μενεξελής μενετός μενσεβικικός
μεξικανικός μερακλίδικος μεραρχιακός μεριδιούχος μερικός μερισματούχος
μεροληπτικός μερσεριζέ μερωνυμικός μεσάτος μεσήλικος μεσήλιξ μεσίστιος μεσαίος
μεσανατολικός μεσεγγυητικός μεσευρωπαϊκός μεσημβρινός μεσημεριάτικος
μεσιακός μεσιανός μεσιτικός μεσοαστικός μεσοβέζικος μεσοβδομαδιάτικος
μεσογειακός μεσοδακτύλιος μεσοζωικός μεσοκοιλιακός μεσοκολπικός μεσοκυρτωτός
μεσολαβητικός μεσολογγίτικος μεσομακροπρόθεσμος μεσομακροχρόνιος μεσομοριακός
μεσοπλεύριος μεσοπολεμικός μεσοποτάμιος μεσοπρόθεσμος μεσοσπονδύλιος
μεσοτονικός μεσοφυλικός μεσοφωνηεντικός μεσοχρόνιος μεσσηνιακός μεσσιανικός
μεσόβιος μεσόγαιος μεσόγειος μεσόκοπος μεσόκυρτος μετάλλινος μετάξινος
μετάρσιος μετέπειτα μετέωρος μεταβατικός μεταβιβάζων μεταβιβάσιμος
μεταβιομηχανικός μεταβλητός μεταβολικός μεταβυζαντινός μεταγγίσιμος
μεταγραφειοκρατικός μεταγραφικός μεταγωγικός μεταδημοκρατικός μεταδοτικός
μεταεισαγωγικός μεταθέσιμος μεταθανάτιος μεταθεραπευτικός μεταθετικιστικός
μεταθετός μεταιχμιακός μετακαπιταλιστικός μετακεντρικός μετακινήσιμος
μετακλασικός μετακλητός μετακοινοβουλευτικός μετακρατικός μεταλαμπαδεύσιμος
μεταλλευτικός μεταλλικός μεταλλογενετικός μεταλλογραφικός μεταλλοειδής
μεταλλουργικός μεταλλοφόρος μεταλυκειακός μεταμαγικός μεταμεσημβρινός
μεταμνημονιακός μεταμοντέρνος μεταμοντερνιστικός μεταμορφικός μεταμορφωσιγενής
μεταμορφώσιμος μεταμφιεσμένος μεταναισθητικός μεταναστευτικός μετανιτσεϊκός
μεταξάς μεταξένιος μεταξοΰφαντος μεταξοειδής μεταξοκλωστικός μεταξοπαραγωγός
μεταπασχαλινός μεταπλαστικός μεταπλαστό μεταπλαστός μεταποιήσιμος
μεταπολεμικός μεταπολιτευτικός μεταπρατικός μεταπτωτικός μεταρηματικός
μεταρρυθμιστικός μεταρσιωτικός μετασεισμικός μετασκευαστικός μετασταθής
μετασυναπτικός μετασχηματιστικός μετασχολικός μετατρέψιμος μετατραυματικός
μεταφερτός μεταφορικός μεταφράσιμος μεταφραστέος μεταφραστικός μεταφυσικός
μεταχειρισμένος μεταχρονολογημένος μεταψυχικός μεταψυχροπολεμικός μετεκλογικός
μετεξεταστέος μετεπιθετικός μετευρετικός μετεωρίτικος μετεωρικός μετεωριτικός
μετεωρολογικός μετεωροσκοπικός μετουσιαστικός μετοχικός μετρήσιμος μετρητικός
μετριαστικός μετρικός μετριοπαθής μετριόφρονας μετριόφρων μετρολογικός
μετωνυμικός μετωπιαίος μετωπικός μετωποκροταφικός μεφιστοφελικός μεφιτικός
μηδαμινός μηδενικός μηδενιστικός μηδικός μηλίτης μηλικογαλακτικός μηλικός
μηλοφόρος μημειακός μηνιαίος μηνιγγικός μηνιγγιτικός μηνοειδής μηνυτήριος
μηρυκαστικός μητριαρχικός μητρικός μητρολογικός μητροπολιτικός μητρωνυμικός
μηχανικός μηχανιστικός μηχανογραφικός μηχανοκίνητος μηχανολογικός
μηχανουργικός μηχανοφόρος μηχανόβιος μιαρός μιασματικός μιγαδικός μιθριδατικός
μικρασιατικός μικροαερόφιλος μικροαστικός μικροβιακός μικροβιοκτόνος
μικροβιομηχανικός μικροβιοφόρος μικρογράμματος μικρογραφικός μικροδάκτυλος
μικροκάμωτος μικροκέφαλος μικροκαμωμένος μικροκατεργάρης μικροκομματικός
μικρολόγος μικρομέγαλος μικρομεσαίος μικρομετρικός μικρομούρης
μικροπαραγοντικός μικροπαραταξιακός μικροπολιτικός μικροπρεπής μικροπρόσωπος
μικροσκοπικός μικροτεχνικός μικροφιλόδοξος μικροφιλότιμος μικροφυής μικροχαρής
μικρούλης μικρούλικος μικρούτσικος μικρόβιος μικρόγλωσσος μικρόθυμος
μικρόμυαλος μικρόνους μικρός μικρόστομος μικρόσχημος μικρόσωμος μικρότερος
μικρόφωνος μικρόχαρος μικρόψυχος μικτοβαρής μικτός μιλανέζικος μιλιμετρέ
μιλιότονος μιμηματικός μιμητικός μιμικός μινιμαλιστικός μινιόν μινωικός μινόρε
μισάνοιχτος μισάρικος μισαλλόδοξος μισελληνικός μισερός μισητός μισθοδίαιτος
μισθολογικός μισθοσυντήρητος μισθοφορικός μισθωτικός μισθωτός μισθόβιος
μισικός μισοάδειος μισογεμάτος μισοδουλεμένος μισοκαμένος μισοξαπλωμένος
μισοπεθαμένος μισοψημένος μισόγυμνος μισόκλειστος μισόξενος μισός μισότρελος
μιτροειδής μιχτός μνημειώδης μνημονιακός μνημονικός μνημοσυναισθηματικό
μνησίκακος μοβ μοβόρικος μοβόρος μογγολικός μοδάτος μοιραίος μοιραστικός
μοιρολατρικός μοιρόγραφτος μοιχικός μολασικός μολασσικός μολδαβικός
μολυβένιος μολυβής μολυβδαινιούχος μολυβδούχος μολυβδόχρους μολυντικός
μολύβδινος μονάζων μονάκριβος μονάλμπουρος μονάρμπουρος μονάχος μονέλικος
μονήρης μοναδιαίος μοναδικός μοναρχικός μοναστηρίσιος μοναστηριακός μοναστικός
μοναχικός μοναχός μονεμβασιώτικος μονεταριστικός μονιάτικος μονιστικός
μονοαπευθυντικός μονοατομικός μονοβλαστικός μονογαμικός μονογενής
μονοεδρικός μονοερωτικός μονοετής μονοζυγωτικός μονοζυγώτης μονοθάλαμος
μονοθεϊστικός μονοκάταρτος μονοκέρατος μονοκατάληκτος μονοκινητήριος
μονοκομματικός μονοκοτυλήδονος μονοκρυσταλλικός μονοκυτταρικός μονοκόκαλος
μονοκότυλος μονοκύλινδρος μονοκύτταρος μονολεκτικός μονολεχτικός μονολιθικός
μονολογικός μονομανής μονομελής μονομερής μονομερίτικος μονομεριάτικος
μονομετοχικός μονοπέταλος μονοπίθανος μονοπαραγωγικός μονοπαραταξιακός
μονοπλοειδής μονοποικιλιακός μονοπρόσωπος μονοπυρηνικός μονοπωλιακός
μονοπύρηνος μονοσάνδαλος μονοσάνταλος μονοσέπαλος μονοσήμαντος μονοσεξουαλικός
μονοστιβαδικός μονοσυλλαβικός μονοσύλλαβος μονοτάξιος μονοτονικός μονοτοπικός
μονοτόκος μονοφασικός μονοφυής μονοφυσιτικός μονοφωνικός μονοχρωματικός
μονοψωνιακός μονοϋβριδικός μονοϋδρικός μοντέρνος μοντερνιστικός μοντεσσοριανός
μονόγαμος μονόγλωσσος μονόκαννος μονόκιλος μονόκλιτος μονόκλωνος μονόκωπος
μονόπατος μονόπλευρος μονόπολος μονόπους μονόπρακτος μονόπτερος μονόριχτος
μονόσημος μονόσπερμος μονόστηλος μονόστιχος μονότομος μονότονος μονότοξος
μονόφθαλμος μονόφθογγος μονόφρων μονόφυλλος μονόφωνος μονόχηλος μονόχνοτος
μονόχορδος μονόχρωμος μονόχωρος μονώνυχος μονώροφος μοραϊτικος μοργανατικός
μορσικός μορτιτικός μορφικός μορφινομανής μορφογενετικός μορφολογικός
μορφοσυντακτικός μορφωματικός μορφωτικός μοσκαναθρεμμένος μοσκαρίσιος
μοσχαρήσιος μοσχαρίσιος μοσχοβίτικος μοσχοβόλος μοσχομυριστός μουγγός μουγκός
μουλαρίσιος μουλλωχτός μουλωχτός μουντζούρης μουντιαλικός μουντρούχος μουντός
μουρμουριστός μουρμούρης μουρντάρης μουρντάρικος μουρόχαυλος μουσάτος
μουσαντένιος μουσειακός μουσειολογικός μουσικοθεατρικός μουσικοκριτικός
μουσικός μουσκφός μουσοτραφής μουσουλμανικός μουστέριος μουσόληπτος μουσόφιλος
μουχρός μοχθηρός μοχλικός μούλικος μούλος μούτικος μούτος μπάνικος μπάσος
μπάσταρδος μπέικος μπέλος μπαγάσικος μπαγαμπόντικος μπαγαπόντης μπαγαπόντικος
μπαγιονέτ μπακάλικος μπακαλίστικος μπακιρένιος μπακλαβαδωτός μπαλαρινέ
μπαμπακένιος μπαμπακερός μπανάλ μπας κλας μπασκετικός μπασμένος μπαστάρδικος
μπατάλικος μπατακτσής μπαταξής μπαταχτσής μπεζ μπεηλίδικος μπεκιάρικος
μπεμπέ μπεμπεδίστικος μπερεκετιλήδικος μπερεκετλήδικος μπερεκετλίδικος
μπερκετλίδικος μπερμπάντικος μπερξονικός μπεϋζιανή μπεϋζιανός μπηχτός
μπινιάρης μπιρμπιλομάτης μπιστικός μπλάβος μπλαζέ μπλαμπλάς μπλε μπλεμαρέν
μποέμικος μπολσεβίκικος μπολσεβικικός μπορετός μπορντελιάρης μπουγιόζικος
μπουμπουνοκέφαλος μπουφόνικος μπούζι μπραιζέ μπρεζέ μπριόζος μπροσέ μπροστινός
μπρούμυτος μπρούντζινος μπρούσικος μπρούσκος μπρούτζινος μπόλικος μπόσικος
μυαλγικός μυαλωμένος μυασθενικός μυατροφικός μυγδαλάτος μυγιάγγιχτος μυελικός
μυελοειδής μυελώδης μυζητικός μυθικός μυθιστορηματικός μυθιστορικός
μυθογραφικός μυθολογικός μυθομανής μυθοπλαστικός μυθοποιητικός μυθώδης
μυκηναϊκός μυκητοειδής μυκητοκτόνος μυκητολογικός μυκητώδης μυκονιάτικος
μυλένιος μυλλωμένος μυξαδενικός μυξιάρης μυξώδης μυοδερματικός μυοκτόνος
μυοσυντονιστικός μυριάκριβος μυριαρίφνητος μυριοστός μυριστικός μυριόνεκρος
μυριόστομος μυριόφωνος μυρμηγκικός μυρμηκικός μυροβόλος μυροφόρος μυρτοειδής
μυρωδάτος μυρωδικός μυσαρός μυστήριος μυσταγωγικός μυστακοφόρος μυστηριακός
μυστικιστικός μυστικοπαθής μυστικός μυτερός μυωπικός μυϊκός μυώδης
μωβ μωροπίστευτος μωροφιλόδοξος μωρόπιστος μωρός μωρόσοφος μωσαϊκός μόνιμος
μόνος μόρσιμος μόρτικος μόσχειος μύξης μύριοι μύρτινος μύχιος μώνυχος νέγρικος
νέτος νήδυμος νήνεμος ναβάχο ναζιάρης ναζιάρικος ναζιστικός ναζωραίος
νανομελής νανοτεχνολογικός νανουριστικός νανουριστός νανοφυής νανοφυία
νανώδης ναξιακός ναξιώτικος ναπολεόντειος ναπολιτάνικος ναρκαλιευτικός
ναρκομανής ναρκωτικός ναρκωτισμός ναστός νατουραλιζέ νατουραλιστικός νατοϊκός
ναυαγοσωστικός ναυαγό ναυαγός ναυαρχικός ναυκληρικός ναυλομεσιτικός
ναυπηγήσιμος ναυπηγικός ναυπηγοεπισκευαστικός ναυπλιώτικος ναυταθλητικός
ναυτικός ναυτιλιακός ναυτιλλόμενος ναυτιών ναυτολογήσιμος ναυτολογικός
νεαντερτάλειος νεαρός νεαττικός νεγκλιζέ νεγροειδής νεκρικός νεκρογέννητος
νεκροδόχος νεκροφάγος νεκροφαγικός νεκροφανής νεκροφοβικός νεκρωτικός νεκρός
νεκρόφιλος νεκρόψυχος νεκρώσιμος νεοέλθων νεοανθρωπιστικός νεοαποικιοκρατικός
νεοαφιχθείς νεογέννητος νεογενής νεογιλός νεογνικός νεογνολογικός νεογοτθικός
νεοδίδακτος νεοδιόριστος νεοεβραϊκός νεοελληνικός νεοεμπρεσιονιστικός
νεοκαπιταλιστικός νεοκλασικός νεολαιίστικος νεολαμπής νεολατινικός νεολιθικός
νεομνημονιακός νεοναζιστικός νεονικοτινοειδής νεοπαγής νεοπαγανιστικός
νεοπλασματικός νεοπλατωνικός νεορεαλιστικός νεορομαντικός νεοσκαφής
νεοτουρκικός νεοτόκος νεοφανής νεοφασιστικός νεοφερμένος νεοφιλελεύθερος
νεοφροϋδικός νεοφυής νεοφυτικός νεοφύτευτος νεοφώτιστος νεοϊμπρεσιονιστικός
νεραϊδογέννητος νεραϊδογεννημένος νεραϊδοπαρμένος νεριτικός νεροκαμένος
νερόβραστος νερόχαρος νερώνειος νετρονικός νευραλγικός νευραξονικός
νευρασθενικός νευρειληματικός νευριαστικός νευρικός νευροαναπτυξιακός
νευροεκφυλιστικός νευροενδοκρινολογικός νευροληπτικός νευρολογικός νευρομυικός
νευροπαθής νευροπαθητικός νευροπαθολογικός νευροφυτικός νευροψυχιατρικός
νευροψυχολογικός νευρωνικός νευρωσικός νευρωτικός νευρώδης νευτόνιος
νεφάριος νεφελοβάμων νεφελοειδής νεφελοσκέπαστος νεφελοσκεπής νεφελώδης
νεφοσκεπής νεφοσκοπικός νεφοϋπολογιστικός νεφράτος νεφραγγειακός νεφραλγικός
νεφριδικός νεφρικός νεφριτικός νεφροειδής νεφρολιθικός νεφρολογικός νεφροπαθής
νεωτερικός νεωτεριστικός νεόβγαλτος νεόδμητος νεόκοπος νεόκτιστος νεόνυμφος
νεόπτωχος νεότατος νεότερος νεότευκτος νεότοκος νεόφερτος νεόφυτος νεόχτιστος
νεώτερος νηκτικός νηλεής νημάτινος νηματοειδής νηματοποιητικός νηματώδης
νηπενθής νηπιακός νηπιώδης νηπτικός νησιωτικός νησιώτικος νησοπυριτικός
νηστικός νηφάλιος νηόμορφος νιγηριανός νικέλινος νικήσιμος νικελιούχος
νικηφόρος νικοτινικός νικοτινοειδής νιοβιούχος νιογέννητος νιος νιοστός
νισυριώτικος νιτρικός νιτροκυτταρινικός νιτρώδης νιτσεϊκός νιχιλιστικός
νιόπαντρος νιόφερτος νιώτικος νοήμονας νοήμων νοεμβριάτικος νοεμβριανός νοερός
νοησιαρχικός νοητικός νοητός νοθογενής νοικοκυρίστικος νοκ-άουτ νομαδικός
νομικίστικος νομικοπολιτικός νομικοταξικός νομικοτεχνικός νομικός
νομιμοφανής νομιμόφρων νομιναλιστικός νομισματικός νομισματοκοπικός
νομοθετικός νομοκατεστημένος νομοκρατούμενος νομολογικός νομοπαρασκευαστικός
νομοτελειακός νομοτελεστικός νομοτεχνικός νομότυπος νοολογικός νορβηγικός
νορμανδικός νοσηλευτικός νοσηρός νοσογόνος νοσοκομειακός νοσοκομειοκεντρικός
νοσομανής νοσοφόρος νοσταλγικός νοστιμούλης νοστιμούλικος νοστιμούτσικος
νοτερός νοτιανατολικός νοτινός νοτιοαμερικανικός νοτιοανατολικός
νοτιοατλαντικός νοτιοαφρικανικός νοτιοβιετναμικός νοτιοδυτικός νοτιοειρηνικός
νοτιοκορεατικός νουνεχής ντέρτικος ντίβα νταμαρήσιος νταμαρίσιος νταμωτός
νταντελωτός ντεκαποτάμπλ ντεκαφεϊνέ ντεκλαρέ ντεκλασέ ντεκουπαριστός
ντεμοντέ ντενεκεδένιος ντεπασέ ντετερμινιστικός ντεψίζης ντεϊστικός ντηνιακός
ντιστεγκές ντοπέ ντουμ-ντουμ ντουμπλ φας ντούζικος ντούρος ντρέτος ντρίτος
ντρεξουδιάρης ντροπαλός ντροπιάρης ντροπιαστικός ντόμπρος ντόπιος νυκτερινός
νυκτός νυμφαίος νυμφικός νυμφομανής νυν νυσταλέος νυφιάτικος νυφικός νυχάτος
νυχτιάτικος νυχτόβιος νωδός νωθρός νωπός νωτιαίος νωχελής νωχελικός νόβιαλ
νόμιμος νόστιμος νότιος νύκτιος νύχτιος ξάγρυπνος ξάστερος ξέγνοιαστος
ξέθαρρος ξέθωρος ξέμακρος ξέμπαρκος ξέμπλεκος ξένιος ξένοιαστος ξένος ξέντυτος
ξέπλεγος ξέπλεκος ξέπλεχτος ξέπνοος ξέσκεπος ξέστηθος ξέστρωτος ξέφραγος
ξέφυλλος ξέφωτος ξέχειλος ξέχωρος ξίκικος ξαγκαθιά ξακουσμένος ξακουστός
ξανθοκόκκινος ξανθομάλλα ξανθομάλλης ξανθομάλλικο ξανθομούστακος ξανθοτρίχης
ξανθωπός ξανθόμαλλος ξανθός ξανθότριχος ξαντικός ξαντός ξαπλωμένος ξαπλωτός
ξασπρουλιάρης ξαφνικός ξεβούλωτος ξεβράκωτος ξεγάνωτος ξεγυριστός ξεγύμνωτος
ξεδιάντροπος ξεδοντιάρης ξεθεωτικός ξεθηλύκωτος ξεκάθαρος ξεκάλτσωτος
ξεκαπάκωτος ξεκαπέλωτος ξεκαπίστρωτος ξεκαρδιστικός ξεκαύλωτος ξεκλείδωτος
ξεκουτιάρης ξεκούδουνος ξεκούμπωτος ξεκούραστος ξεκούρδιστος ξεκούρντιστος
ξεκρέμαστος ξεκωλιάρης ξεκόλλητος ξεμέθυστος ξεμαλλιάρης ξεμαλλιασμένος
ξεματιασμένος ξεμπράτσωτος ξενέρωτος ξενηστικωμένος ξενικός ξενοίκιαστος
ξενοκίνητος ξενοκρατικός ξενομανής ξενοπρεπής ξενοφανής ξενοφοβικός
ξενόγλωσσος ξενόδουλος ξενότροπος ξενόφερτος ξενόφιλος ξενόφοβος ξενόφωνος
ξερικός ξεροκέφαλος ξεροψημένος ξερός ξεσέλωτος ξεσαβούρωτος ξεσαμάρωτος
ξεσκέπαστος ξεσκούφωτος ξεστός ξετσίπωτος ξεφούσκωτος ξεχαρβάλωτος
ξεχασιάρης ξεχτένιστος ξεχωριστός ξεψάρωτος ξημαρισμένος ξηραντικός
ξηρός ξηρόφιλος ξιδάτος ξινισμένος ξινούτσικος ξινόγλυκος ξινός ξιπασιάρης
ξιφήρης ξιφοειδής ξιφοφόρος ξομπλιαστός ξορκισμένος ξούτσκος ξυλάρμενος
ξυλεμπορικός ξυλογλυπτικός ξυλογραφικός ξυλοειδής ξυλοπόδαρος ξυλοσκέπαστος
ξυλοφάγος ξυλοχρωστικός ξυλόγλυπτος ξυλόσοφος ξυλόστρωτος ξυλόφρακτος ξυλώδης
ξυπνός ξυπόλητος ξυπόλυτος ξυριστικός ξυστικός ξυστός ξωτικός ξύλινος ξύπνιος
ξώφτερνος οβάλ οβελιαίος ογαμικός ογδοηκονθήμερος ογδοηκονταετής ογδοντάχρονος
ογκομετρικός ογκωδέστερος ογκώδης ογλήγορος ογρός οδηγητικός οδηγικός οδικός
οδομετρικός οδοντιατρικός οδοντικός οδοντογραφικός οδοντοειδής
οδοντοπρόφερτος οδοντορραγικός οδοντοτεχνικός οδοντοφατνιακός οδοντοφόρος
οδοντόφωνος οδοποιητικός οδυνηρός οδυσσειακός οδωνυμικός οζαινικός οζαινώδης
οζοντομετρικός οζώδης οθνείος οθωμανικός οθωνικός οθώνειος οιακοφόρος οιδαλέος
οιδιπόδειος οικήσιμος οικείος οικειοθελής οικιακός οικιστικός οικογενειακός
οικοδίαιτος οικοδομήσιμος οικοδομικός οικοδομοτεχνικός οικολογικός
οικονομικός οικονομολογικός οικονομοτεχνικός οικονόμος οικοσημικός
οικοτεχνικός οικοτουριστικός οικουμενικός οικουρός οικτίρμων οικτρός οικόσιτος
οινοβαρής οινοβαφής οινοειδής οινολογικός οινομανής οινομετρικός οινοπαραγωγός
οινοπνευματοποιήσιμος οινοπνευματούχος οινοπνευματώδη οινοπνευματώδης
οινοχαρής οινόφιλος οινώδης οισοφάγειος οισοφαγικός οιστρήλατος οκαδιάρικος
οκνός οκτάγωνος οκτάεδρος οκτάμηνος οκτάπλευρος οκτάπους οκτάστηλος οκτάστιχος
οκτάτευχος οκτάτομος οκτάφωνος οκτάχορδος οκτάχρονος οκτάωρος οκταήμερος
οκταδικός οκταετής οκτακοσιοστός οκτακόσιοι οκταμελής οκταπλάσιος οκταπλούς
οκτασέλιδος οκτασύλλαβος οκταψήφιος οκταώροφος οκτωβριάτικος οκτωβριανός
ολάκερος ολάνοιχτος ολάρφανος ολάσπρος ολέθριος ολίγιστος ολίγος ολιγάνθρωπος
ολιγαρκής ολιγαρχικός ολιγοέξοδος ολιγοήμερος ολιγοβαρής ολιγογράμματος
ολιγοδάπανος ολιγοδίαιτος ολιγοδύναμος ολιγοεδρικός ολιγοετής ολιγοκτήμων
ολιγομελής ολιγομερής ολιγοπράγμων ολιγοσέλιδος ολιγοστός ολιγοσύλλαβος
ολιγοφάγος ολιγοχρήματος ολιγοχρόνιος ολιγόζωος ολιγόθερμος ολιγόκαρδος
ολιγόκοσμος ολιγόλεπτος ολιγόλογος ολιγόνους ολιγόπιστος ολιγόσιτος
ολιγόστιχος ολιγόταστος ολιγότεκνος ολιγόχρονος ολιγόψυχος ολιγόωρος ολικός
ολιστικός ολλανδέζικος ολλανδικός ολοήμερος ολογάλανος ολογλήγορος ολογραφικός
ολοζώντανα ολοζώντανος ολοκάθαρος ολοκαίνουργος ολοκαίνουριος ολοκληρωμένος
ολοκληρώσιμος ολοκλησικός ολοκυκλικός ολοκόκκινος ολομέταξος ολομέτωπος
ολομερής ολομόναχος ολονύκτιος ολονύχτιος ολοπαγής ολοπαθής ολοπράσινος
ολοπόρφυρος ολοσκέπαστος ολοσκότεινος ολοστρόγγυλος ολοστόλιστος ολοσυστημικός
ολοφάνερος ολοφανής ολοφυρόμενος ολυμπιακός ολυνθιακός ολόασπρος ολόγεμος
ολόγιομος ολόγλυκος ολόγλυφος ολόγραφος ολόγυμνος ολόγυρος ολόδροσος ολόημερος
ολόθυμα ολόθυμος ολόιδιος ολόισος ολόκαρδος ολόκλειστος ολόκληρος ολόκορμος
ολόλευκος ολόμαλλος ολόμαυρος ολόμοιος ολόξανθος ολόξενος ολόπλευρος ολόπρωτος
ολόσκεπος ολόστεγνος ολόστρωτος ολόσωμος ολόφρεσκος ολόφωτος ολόχαρος
ολόχρωμος ολόψυχος ολύμπιος ομήλικος ομήλιξ ομήρειος ομαδικός ομαλός ομηρικός
ομιχλιασμένος ομιχλώδης ομοαξονικός ομογάλακτος ομογάλαχτος ομογάστριος
ομογενειακός ομογενοποιημένος ομογονεϊκός ομογραφικός ομοεθνής ομοειδής
ομοετής ομοζυγωτικός ομοζυγώτης ομοιογενής ομοιοεπαγγελματικός ομοιοκάταρκτος
ομοιοκατάληχτος ομοιομερής ομοιοπαθής ομοιοπαθητικός ομοιοπολικός
ομοιοτροπικός ομοιούσιος ομοιωματικός ομοιόβαθμος ομοιόγραφος ομοιόθερμος
ομοιόπτωτος ομοιόσχημος ομοιότροπος ομοιότυπος ομοιόφωνος ομοιόχρονος
ομοκεντρικός ομολογητικός ομολογιακός ομολογιούχος ομομήτριος ομοούσιος
ομοπλαστικός ομορφοφτιαγμένος ομορφότατος ομορφότερος ομοσκεδαστικός
ομοταγής ομοτράπεζος ομοτυπικός ομοφοβικός ομοφυλοφιλικός ομοφυλόφιλος
ομπρελοειδής ομφάλιος ομφαλικός ομφαλοειδής ομφαλοκυστικός ομφαλοπλακουντιακός
ομφαλώδης ομόγλωσσος ομόγονος ομόγραφος ομόδικος ομόδοξος ομόζυγος ομόηχος
ομόθυμος ομόκεντρος ομόλογος ομόρριζος ομόρρυθμος ομόσημος ομόσιτος ομόσπονδος
ομότιμος ομότιτλος ομότοιχος ομότονος ομότροπος ομότροφος ομότυπος ομόφρων
ομόφωνος ομόχρονος ομόχρωμος ομόψηφος ομόψυχος ομώνυμος ονδουρικός
ονειρευτός ονειρικός ονειρογέννητος ονειροκριτικός ονειροπαρμένος
ονειροπολικός ονειροπόλος ονειρωκτικός ονειρόπλαστος ονειρώδης ονικός ονλάιν
ονομαστικός ονομαστός ονοματικός ονοματοκρατικός ονοματολογικός ονοματοποίητος
οντολογικός οντουλέ ονυχαίος ονυχοειδής ονυχοφόρος οξένιος οξαλικός οξεάντοχος
οξειδωτικός οξειδώσιμος οξιδωτικός οξιδώσιμος οξικός οξιτανικός οξονικός
οξυγονικός οξυγονούχος οξυγώνιος οξυδερκής οξυκέφαλος οξυκόρυφος οξυμετρικός
οξύγναθος οξύθυμος οξύινος οξύληκτος οξύμαχος οξύμωρος οξύνους οξύρρυγχος οξύς
οξύφυλλος οξύφωνος οξύχηος οπάκ οπίσθιος οπαίος οπαλιοειδής οπαλιόχρους
οπιομανής οπιοφάγος οπιούχος οπισθοβατικός οπισθογεμής οπισθοδρομικός
οπισθοφύλακας οπισθοχωρητικός οπισθόβουλος οπισθόγραφος οπιώδης οπλομαχητικός
οπορτουνιστής οπορτουνιστικός οπτικοακουστικός οπτικός οπτιμιστικός οπτός
οπωροφόρος οπώδης ορατικός ορατός οργίλος οργανικός οργανογενής
οργανογραφικός οργανογόνος οργανοειδής οργανοληπτικός οργανολογικός
οργανοχημικός οργανωτικοδιοικητικός οργανωτικός οργανώσιμος οργασμικός
οργιστικός οργιώδης οργώσιμος ορειβατικός ορεινός ορειχάλκινος ορειχαλκόχρους
ορεξάτος ορεογραφικός ορεομετρικός ορεσίβιος ορεχτικός ορθάνοιχτος
ορθογραφικός ορθογώνιος ορθοδοντικός ορθοεπής ορθολογικός ορθολογιστικός
ορθοπαιδικός ορθοπεδικός ορθοπρωκτικός ορθοπτικός ορθοπυριτικός ορθοσκοπικός
ορθρινός ορθόβουλος ορθόδοξος ορθόδρομος ορθός ορθόστοιχος ορθότοπος οριακός
ορισμένος ορισματικός οριστέος οριστικός ορκοδοτικός ορκωτός ορμέμφυτο
ορμητικός ορμογόνος ορμονικός ορμονολογικός ορνιθοειδής ορνιθοκομικός
ορνιθόμορφος ορνιθόμυαλος ορνιθόρρυγχος οροαιματώδης ορογενετικός ορογραφικός
ορολογικός ορομετρικός οροφιαίος ορτός ορυκτογεωλογικός ορυκτογραφικός
ορυκτοτεχνικός ορυκτός ορφανικός ορφανός ορφικός ορφνός ορχηστικός ορχηστρικός
ορχιτικός ορώδης οσκαρικός οσμήρης οσμανικός οσμηγόνος οσμηρός οσμικός
οσμογόνος οσμομετρικός οσπριοειδής οσπριοφάγος οστέινος οστεοαρθρικός
οστεογόνος οστεοειδής οστεολογικός οστεολυτικός οστεομετρικός οστεομυελικός
οστεοφόρος οστεωδυνικός οστεωτικός οστεόμορφος οστεώδης οστικός οστρακοειδής
οστρακόδερμος οστρακώδης οστρογοτθικός οσφραντικός οσφρητικός οσφυαλγικός
οσφυϊκός οτρηρός ουαλικός ουαλονικός ουγγαρέζικος ουγγρικός ουδέτερος
ουδετερόφιλος ουκρανικός ουλόθριξ ουλώδης ουμανιστικός ουνιταριανός ουνιτικός
ουραίος ουραλοαλταϊκός ουρανής ουρανικός ουρανισκόφωνος ουρανοβάμων
ουρανογραφικός ουρανοκατέβατος ουρανομήκης ουρανόπεμπτος ουρανόσταλτος
ουρηθρικός ουρηθροεντερικός ουρηθροκολπικός ουρηθροσκοπικός ουρητηροκολπικός
ουρητικός ουρικός ουρογεννητικός ουροδόχος ουρολάγνος ουρολογικός
ουροποιογεννητικός ουροσκοπικός ουρουγουανικός ουροφόρος ουσιαστικός ουσιώδης
ουτοπικός ουτοπιστικός οφειλετικός οφθαλμιατρικός οφθαλμικός οφθαλμολογικός
οφθαλμοφανής οφθαλμοφανώς οφιοειδής οφιολιθικός οφιόδηκτος οφλάιν οφτός
οχηματαγωγός οχλαγωγικός οχληρός οχλοκρατικός οχτάγωνος οχτάεδρος οχτάμηνος
οχτάστηλος οχτάστιχος οχτάστυλος οχτάτομος οχτάχρονος οχτάωρος οχταήμερος
οχτακοσιοστός οχτακόσιοι οχταμελής οχταπλάσιος οχταπλός οχτασύλλαβος
οχτωβριανός οχυρωματικός οχυρωτικός οχυρός οψίπλουτος οψιγενής οψιμαθής ούλος
οὐσιαστικός πάγιος πάγκαλος πάγκοινος πάλλευκος πάμπλουτος πάμπολλοι πάμφθηνος
πάμφωτος πάναγνος πάνδημος πάνινος πάνοπλος πάνσεπτος πάνσοφος πάρεργος
πάρθιος πάριος πάρωρος πάτριος πένθιμος πέτρινος πέτσικος πέτσινος πήλινος
πίβουλος πίσω πίτσικος παγανιστικός παγγερμανιστικός παγερός παγετωνικός
παγιωτής παγιωτοπικός παγκάκιστος παγκαλόμορφος παγκατευθυντικός
παγκρεατικός παγκρητικός παγκυπριακός παγκόσμιος παγοδρομικός παγοθραυστικός
παγχαλκιδικός παγωμένος παγόπληκτος παζαρίσιος παζαριάτικος παθητικοεπιθετικός
παθιάρης παθιάρικος παθογόνος παθολογικός παθολογοανατομικός παθοπλάνταχτος
παιδαγωγικός παιδαριώδης παιδεραστικός παιδευτικός παιδιάστικος παιδιάτικος
παιδιακίστικος παιδιατρικός παιδικός παιδοκομικός παιδολογικός παιδομετρικός
παινεσιάρης παιχνιδιάρης παιχνιδιάρικος πακιστανικός παλίλλογος παλίμβουλος
παλίμψηστος παλίνδρομος παλαίτυπος παλαίφατος παλαβός παλαιικός
παλαιογεωγραφικός παλαιογραφικός παλαιοεθνολογικός παλαιοζωικός
παλαιοκομματικός παλαιολιθικός παλαιοντολογικός παλαιοπωλικός
παλαιστίνιος παλαιστικός παλαιστινιακός παλαιός παλαιότατος παλαιότερος
παλαμικός παλαμοειδής παλαμοκροτώ παλαμοσχιδής παλατιανός παλικαρίσιος
παλινδρομικός παλιομοδίτικος παλιομουράτος παλιρροιακός παλιρροϊκός παλιός
παλλακωνικός παλλαμιακός παλλαϊκός παλληκαρίσιος παλμικός παμβαλκανικός
παμμέγιστος παμμαγνησιακός παμμακεδονικός παμμαύρος παμμεσηνιακός παμπάλαιος
παμπειραϊκός παμπελοποννησιακός παμπληθής παμπόνηρος παμφάγος πανάγαθος
πανάθλιος πανάκριβος πανάμωμος πανάρχαιος πανάσχημος πανάχραντος πανέ
πανένδοξος πανέξυπνος πανέρημος πανέρμος πανέτοιμος πανίερος πανίσχυρος
παναθηναϊκός παναιτωλικός πανακαρνανικός παναμερικανικός παναμώμητος
παναραβικός παναργολικός παναρκαδικός πανασιατικός παναττικός παναφρικανικός
πανδημικός πανδραμαϊκός πανεδεσσαϊκός πανεθνικός πανελλήνιος πανελλαδικός
πανεπιστημιακός πανεργατικός πανευβοϊκός πανευδαίμων πανευρωπαϊκός πανευτυχής
πανηγυρικός πανηγυριώτικος πανηλειακός πανηλικιακός πανηπειρωτικός
πανθεσσαλικός πανθεϊστικός πανθρακικός πανικόβλητος πανινός πανιώνιος
πανομοιότυπος πανοραματικός πανοραμικός πανορθοδοξιακός πανορθόδοξος
πανουκλιασμένος πανούργος πανσεβάσμιος πανσερραϊκός πανσλαβικός πανσλαβιστικός
παντέρημος παντέρμος παντελής παντελεήμων παντοίος παντοδαπός παντοδύναμος
παντοθενικός παντοκατευθυντικός παντοκρατορικός παντομιμικός παντοτινός
παντοφλέ παντοφοβικός παντρεμένος πανωλόβλητος πανόδετος πανόμοιος πανόσιος
πανώριος παπίσιος παπαγαλίστικος παπαδίστικος παπανδρεϊκός παπικός
παπουτσωμένος παππουδίστικος παπυρικός παπυρογραφικός παπυρολογικός παπύρινος
παράβυστος παράγωγος παράγωνος παράδοξος παράθυρος παράκαιρος παράκεντρος
παράκουος παράκτιος παράλιος παράλληλος παράλογος παράλος παράλυτος παράμερος
παράνθιος παράνομος παράνους παράξενος παράουρος παράπλευρος παράπλευστος
παράσπονδος παράταιρος παράτολμος παράτονος παράτροπος παράτυπος παράφορος
παράφωνος παράχορδος παρένθετος παρέστιος παρήγορος παρήκοος παρήλικος
παρήμερος παρίσθμιος παραίτιος παραβαλβιδικός παραβατικός παραβιωτικός
παραβρασμένος παραγγελιοδοχικός παραγγελτικός παραγεμιστός παραγοντίστικος
παραγωγίσιμος παραγωγικός παραδασόβιος παραδείσιος παραδειγματικός
παραδεισιακός παραδεκτός παραδεχτός παραδοξολόγος παραδοσιακός παραδοτέος
παραδόπιστος παραεκκλησιαστικός παραθαλάσσιος παραθεριστικός παραθετικός
παραινετικός παραισθησιογόνος παραισθητικός παρακάτω παρακαλεστικός
παρακαλετός παρακαμπτήριος παρακαμπτικός παρακατιανός παρακείμενος
παρακεντέδικος παρακεντρικός παρακινδυνευτικός παρακινητικός παρακλαδικός
παρακλινικός παρακμάζων παρακμιακός παρακοιμώμενος παρακρατικός παραλίμνιος
παραληρητικός παραλιακός παραλλακτικός παραλληλεπίπεδος παραλληλόγραμμος
παραλογιστικός παραλυτικός παραμήτριος παραμαγνητικός παραμακρύς παραμεθόριος
παραμεσόγειος παραμετρικός παραμετροποιήσιμος παραμητρικός παραμικρός
παραμυθένιος παραμυθητικός παραμόνιμος παρανεφρικός παρανιός παρανοειδής
παρανοϊκός παραξόνιος παραπανήσιος παραπανίσιος παραπανιστός παραπειστικός
παραπλήσιος παραπλανητικός παραπληκτικός παραπληρωματικός παραπολιτικός
παραπονιάρικος παραποτάμιος παραρίνιος παραρρίνιος παραρρίνιων παραρριξιμιός
παρασημαντικός παρασημοφορημένος παρασιτικός παρασιτοκτόνος παρασιτολογικός
παρασκηνιακός παρασούσουμος παρασπονδυλικός παραστατικός παραστρατιωτικός
παρασυγγενικός παρασυμπαθητικός παρασύνθετος παρατακτικός παραταξιακός
παρατετραμμένος παρατηρητικός παρατυφικός παραφιλικός παραφραστικός παραφυλία
παραφυλλωματικός παραφυσικός παραχειμαστικός παραχριστιανικός παραχωρητικός
παραϊατρικός παρδαλός παρείσακτος παρεγκεφαλιδικός παρεγχυματικός
παρειακός παρεκβατικός παρεκκλίνων παρελθοντικός παρελκυστικός παρελκόμενος
παρεμφατικός παρεμφερής παρενδυτικός παρενθετικός παρενοχλητικός παρεντερικός
παρεξηγησιάρης παρεπίδημος παρεπιδημών παρεστιγμένος παρετυμολογικός
παρηγορητικός παρηχητικός παρθένος παρθενικός παρθενωπός παρθικός παριανός
παρισινός παρλιακός παρμένος παρνασσιακός παροδικός παροιμιακός παροιμιώδης
παροντικός παροξυντικός παροξυσμικός παροξύτονος παρορμητικός παροτρυντικός
παροχετευτικός παρρησιαστικός παρτιζάνικος παρτσακλός παρυδάτιος παρωδιακός
παρόμοιος παρόμοιος παρόχθιος παρών παρώνυμος πασέ πασίγνωστος πασίδηλος
πασαλίδικος πασιφανής πασιφιστικός πασπάτης πασπαλισμένος πασπαλιστός
πασσαλόκτιστος πασσαλόπηκτος παστρικός παστός πασχαλιάτικος πασχαλινός
πατεντάτος πατερναλιστικός πατητός πατικωμένος πατμιακός πατραϊκός
πατρικός πατρινός πατριωτικός πατρογονικός πατρολογικός πατροπαράδοτος
πατρωνυμικός πατρώος πατσόκοιλος παυσίλυπος παυσίπονος παφιλένιος
παχουλός παχυλός παχυντικός παχύδερμος παχύρρευστος παχύς παχύσαρκος παχύσκος
παχύτερος παχύφυλλος πείσμων πεδιλωτός πεδινός πεζικός πεζογραφικός
πεζολογικός πεζοναυτικός πεζοπορικός πεζοπόρος πεζόμορφος πεζός πεθαμένος
πειθήνιος πειθαρχικός πειναλέος πειραιώτικος πειρακτικός πειραματικός
πειραχτικός πειραϊκός πεισιθάνατος πεισματάρης πεισματάρικος πεισματικός
πειστικός πειστικότερος πελάγιος πελαγίσιος πελαγικός πελαγοδρόμος πελασγικός
πελατοκεντρικός πελεκητός πελεκυφόρος πελελός πελιδνός πελματιαίος πελματικός
πελώριος πεμπταίος πεμπτιάτικος πεμπτουσιώδης πενηντάρης πενηντάρικος
πενηνταπεντάχρονος πενθήμερος πενθερικός πενθημιμερής πενιέ πενιχρός
πεντάγωνος πεντάδιπλος πεντάεδρος πεντάκλιτος πεντάκλωνος πεντάκλωστος
πεντάλεπτος πεντάμετρος πεντάμηνος πεντάμορφος πεντάξενος πεντάπλευρος
πεντάπρακτος πεντάπυλος πεντάρικος πεντάρφανος πεντάσημος πεντάστιχος
πεντάτομος πεντάφυλλος πεντάφωνος πεντάφωτος πεντάχορδος πεντάχρονος
πεντάωρος πενταήμερος πενταβρωμιούχος πενταγωνικός πενταγώνιος πενταδάκτυλος
πενταδικός πενταετής πεντακάθαρος πεντακοσιοστός πεντακόσιοι πεντακόσοι
πενταμερής πεντανικός πεντανόστιμος πενταπέταλος πενταπλάσιος πενταπλούς
πεντασύλλαβος πενταψήφιος πεντελίσιος πεντελικός πεντηκονθήμερος
πεντοζάλης πεντόκλιτος πεπιεσμένος πεπλανημένος πεπολιτισμένος πεπονοειδής
πεπρωμένος πεπτικός περήφανος περίακτος περίβλεπτος περίγλυφος περίδακρυς
περίδοξος περίεργος περίκλειστος περίκομψος περίλαμπρος περίλειστος περίλυπος
περίοπτος περίπλοκος περίπτερος περίπτυστος περίπυστος περίσκεπτος περίσκιος
περίσσος περίστρεπτος περίστυλος περίτεχνος περίτμητος περίτονος περίτρανος
περίφημος περίφοβος περίφρακτος περίφραχτος περίφροντις περίχαρος περίχρυσος
περαστικός περαστός περατός περβολάρικος περβολαρίσιος περγαμηνοειδής
περιαιρετός περιαλγής περιαρθρικός περιαστικός περιαυγής περιαυτολόγος
περιβαλλοντικός περιβαλλοντολογικός περιβολάρικος περιβολίσιος περιβολαρίσιος
περιγάμητος περιγέλαστος περιγελαστικός περιγεννητικός περιγραφικός
περιδεής περιεδρικός περιεκτικός περιεμφραγματικός περιεχτικός περιζήτητος
περιθηλαίος περιθωριακός περικαλλής περικαρδικός περικαρπιακός περικαρπικός
περικλεής περιλάλητος περιλαμπής περιληπτικός περιλιμπανόμενος περιμάχητος
περιμητρικός περιοδεύον περιοδικός περιοδοντικός περιορίσιμος περιοριστικός
περιουσιακός περιοχικός περιούσιος περιπαθής περιπαικτικός περιπαιχτικός
περιπετειώδης περιπλανητικός περιποιητικός περιπολικός περιπόθητος περιρρέων
περισκωληκοειδικός περισπούδαστος περισσευάμενος περισσευούμενος περισσός
περισταλτικός περιστασιακός περιστατικός περιστερίσιος περιστροφικός
περιτραχήλιος περιττοδάκτυλος περιττολόγος περιττοσύλλαβος περιττωματικός
περιφανής περιφερής περιφερειακός περιφερικός περιφλεγής περιφραστικός
περιφρονητικός περιχαρής περιχυτός περιώνυμος περμανάντ περονιαίος περονοφόρος
περπατάρης περσικός περσινός περσότερος περυσινός πεσιμιστικός πεσμένος
πεταλοειδής πεταλωτικός πεταλωτός πεταχτούλης πεταχτός πετεινόμυαλος πετρένιος
πετραρχικός πετρελαιοειδής πετρελαιοκίνητος πετρελαιοπιθανός πετρελαιοφόρος
πετρογενετικός πετρογραφικός πετροφυής πετροχημικός πετρωτός πετρόλ πετρόψυχος
πετσένιος πετσετέ πετσετένιος πετυχημένος πευκόφυτος πεόμορφος πεόσχημος
πηγαίος πηγαδίσιος πηδαλιουχούμενος πηδητικός πηδηχτός πηκτικός πηκτός
πηλώδης πηροδάκτυλος πηρομελής πηχεοκαρπικός πηχτός πηχυαίος πιανιστικός
πιδέξιος πιεζοηλεκτρικός πιεσμένος πιεστικός πιεστός πιθανικός
πιθανοστατιστικός πιθανοτικός πιθανός πιθηκικός πιθηκοειδής πιθηκόμορφος
πικέ πικραμένος πικραντικός πικρικός πικροαίματος πικροθρήνητος πικρούτσικος
πικρόγλωσσος πικρόκαρδος πικρός πικρόχολος πικτουρέσκ πιλοτικός πινακογραφικός
πινδαρικός πιπεράτος πιπιλιστός πιρουνάτος πισινός πισσωτός πιστευτός
πιστοληπτικός πιστοποιητικός πιστούχος πιστωτικός πιστός πιστότερος πισώπλατος
πιτσιλιστός πιτσιλωτός πιτυριδικός πιτυρούχος πιωμένος πιότερος πλάγιος πλάνης
πλέριος πλήθιος πλήρης πλίθινος πλίνθινος πλαγιαστός πλαγινός πλαγιοδετημένος
πλαγκτονικός πλαδαρός πλακάτος πλακέ πλακομύτης πλακουτσωτός πλακουτσός
πλακόστρωτος πλακώδης πλανεμένος πλανερός πλανημένος πλανητικός πλανητοειδής
πλανόδιος πλασαριστός πλασματικός πλασμωδιακός πλαστικοποιητικός πλαστικός
πλαστός πλατειαστικός πλατινέ πλατινένιος πλατινοειδής πλατσουκωτός
πλατυκέφαλος πλατυκυρτωτός πλατυμέτωπος πλατυπόδαρος πλατυπύθμενος
πλατωνικός πλατύγυρος πλατύκερως πλατύκυρτος πλατύποδας πλατύπους πλατύρρινος
πλατύστερνος πλατύστομος πλατύσωμος πλατύτερος πλατύφυλλος πλατύχωρος πλαϊνός
πλείων πλείων πλειοδοτικός πλειοψηφικός πλειόμορφος πλεκτικός πλεκτός
πλεονασματικός πλεοναστικός πλεονεκτικός πλευρικός πλευριτικός πλευροκοπικός
πλεχτικός πλεχτός πλεύσιμος πληγωτικός πληθικός πληθυντικός πληθυσμιακός
πληθωρικός πληθωριστικός πληκτικός πληκτροφόρος πλημμελής πλημμεληματικός
πληρεξούσιος πληροφοριακός πληροφορικός πληρωτέος πληρωτικός πλησίος
πλησιέστερος πλησιοπαράλληλος πλησιφαής πλησιόχωρος πληχτικός πλινθοδομικός
πλινθόκτιστος πλιότερος πλοηγικός πλοιοκεντρικός πλουμιστός πλουραλιστικός
πλουτοκρατικός πλουτολογικός πλουτοπαραγωγικός πλουτοφόρος πλουτώνιος πλοϊκός
πλυντήριος πλυντικός πλωριός πλωτικός πλωτός πλόιμος πνευματικός
πνευματοκτόνος πνευματώδης πνευμονικός πνευμονογαστρικός πνευμονογραφικός
πνευστός πνιγηρός πνιχτικός πνιχτός ποδήρης ποδαράτος ποδηλατικός ποδικός
ποδοκνημικός ποδοσφαιρικός ποζάτος ποζολανικός ποθεινός ποθεινότατος ποθερός
ποιητικός ποικίλος ποικιλτικός ποικιλόγραμμος ποικιλόθερμος ποικιλόμορφος
ποικιλόσχημος ποικιλότροπος ποικιλόφωνος ποικιλόχρωμος ποικιλώνυμος
ποιμαντορικός ποιμενίς ποιμενικός ποινικός ποιοτικός πολέμιος πολίτικος
πολεμιστήριος πολεμοκάπηλος πολεμοπαθής πολεμοποιός πολεμοχαρής πολεμόχαρος
πολεομορφικός πολεοτικός πολικός πολιομυελιτικός πολιορκητικός πολιτειακός
πολιτικοδικαστικός πολιτικοδιοικητικός πολιτικοκοινωνικός πολιτικομανής
πολιτικοστρατιωτικός πολιτικός πολιτισμένος πολιτισμικός πολιτιστικός πολιός
πολλαπλασιαστικός πολλαπλός πολλοστός πολτοειδής πολτώδης πολυάνθρωπος
πολυάστερος πολυάσχολος πολυέλεος πολυέξοδος πολυήμερος πολυαίματος πολυαίωνος
πολυαγγειακός πολυαισθητηριακός πολυακόρεστος πολυανδρικός πολυανθής
πολυαρχικός πολυβάλβιδος πολυβασανισμένος πολυγαμικός πολυγαστρικός
πολυγραφικός πολυγραφότατος πολυγωνικός πολυδάκρυτος πολυδάκτυλος πολυδάπανος
πολυδαίδαλος πολυδιάστατος πολυδιαστρωματωμένος πολυδόξαστος πολυδύναμος
πολυεθνικός πολυειδής πολυεπιστημονικός πολυεστερικός πολυεστιακός πολυετής
πολυεύσπλαγχνος πολυεύσπλαχνος πολυζήλευτος πολυζήτητος πολυζηλεμένος
πολυηχής πολυθέλγητρος πολυθεϊκός πολυθεϊστικός πολυθρήνητος πολυθρύλητος
πολυκάτεχος πολυκέλαδος πολυκέφαλος πολυκαιρίτικος πολυκαιρινός
πολυκεντρικός πολυκερδής πολυκλαδικός πολυκομματικός πολυκριτηριακός
πολυκυστικός πολυκυτταρικός πολυκύλινδρος πολυκύμαντος πολυκύτταρος
πολυλεκτικός πολυλογάδικος πολυμέριμνος πολυμέτωπος πολυμήχανος πολυμαθής
πολυμερής πολυμερικός πολυμεταβλητός πολυμετοχικός πολυμορφικός πολυνησιακός
πολυξακουσμένος πολυοζώδης πολυουρεθανικός πολυουρικός πολυπέταλος
πολυπαθής πολυπαραγοντικός πολυπαραμετρικός πολυπαραταξιακός πολυπλάνητος
πολυπληθής πολυπλόκαμος πολυποίκιλος πολυπολιτισμικός πολυπονεμένος
πολυπραγματικός πολυπρόσωπος πολυπυρηνικός πολυπόθητος πολυπύρηνος πολυσέλιδος
πολυσήμαντος πολυσκελής πολυστένακτος πολυσυλλεκτικός πολυσυμπαντικός
πολυσύλλαβος πολυσύνδετος πολυσύνθετος πολυσύχναστος πολυτάλαντος πολυτάραχος
πολυτασικός πολυτελής πολυτεχνικός πολυτμήματος πολυτμηματικός πολυτομικός
πολυτοπικός πολυτροπικός πολυτόκος πολυφάγος πολυφίλητος πολυφασικός πολυφυής
πολυφωνικός πολυχρήματος πολυχρόνιος πολυψήφιος πολυωνυμικός πολυύμνητος
πολυώροφος πολφικός πολωνέζικος πολωνικός πολωτικός πολύαιμος πολύανδρος
πολύαστρος πολύβλαστος πολύβοος πολύβουλος πολύβουος πολύγαμος πολύγλωσσος
πολύγνωρος πολύγονος πολύγραμμος πολύγωνος πολύδακρυς πολύδεντρος πολύδροσος
πολύεδρος πολύηχος πολύθρησκος πολύκαρπος πολύκλαδος πολύκλαυστος πολύκλαυτος
πολύκροτος πολύλαλος πολύλογος πολύμορφος πολύμοχθος πολύνευρος πολύξερος
πολύπαθος πολύπειρος πολύπλευρος πολύπλοκος πολύποδος πολύπονος πολύπορος
πολύπτυχος πολύπτωτος πολύριζος πολύρριζος πολύς πολύσαρκος πολύσημος
πολύσπορος πολύστηλος πολύστικτος πολύστιχος πολύστροφος πολύστυλος
πολύταστος πολύτεκνος πολύτεχνος πολύτιμος πολύτμητος πολύτοκος πολύτομος
πολύτριχος πολύτροπος πολύυδρος πολύφερνος πολύφημος πολύφθογγος πολύφροντις
πολύφωνος πολύφωτος πολύχορδος πολύχρονος πολύχρυσος πολύχρωμος πολύχυμος
πολύωρος πομπικός πομπώδης πονεμένος πονεσιάρης πονετικός πονηρός ποντιακός
ποντικοκτόνος ποντικοφαγωμένος ποντιφικός ποντοπόρος πονόκαρδος πονόψυχος
πορευτικός ποριστικός ποριώτικος πορνικός πορνογραφικός πορνό ποροσκοπικός
πορτογαλέζικος πορτογαλικός πορτοκαλής πορτοκαλί πορτοκαλόχρους πορφυρένιος
πορφυρογέννητος πορφυρός πορφυρόχρους πορφυρόχρωμος πορώδης ποσέ ποσαπλάσιος
ποσοστιαίος ποσοστιαίως ποσοστικός ποσοτικοποιήσιμος ποσοτικός ποτάμιος
ποταμογενής ποταμοχειμάρρειος ποταπός ποτιστικός πουπουλένιος πουριτανικός
πουτανίστικος πουτανιάρης πούρος πούστικος ποώδης πράος πράσινος πρίμος
πραγματιστικός πραγματογνωστικός πραγματοκρατικός πραγματολογικός
πραιτορικός πραιτωρικός πρανής πραξεολογικός πραξικοπηματικός πρασινογάλαζος
πρασινομάτης πρασινωπός πραχτικός πραϋντικός πρεβεζιάνικος πρεμνοφυής
πρεσβευτικός πρεσβυγενής πρεσβυτικός πρεσβυωπικός πρεσβύτερος πρεσοκομμένος
πριάπειος πριβέ πριγκιπικός πριμιτιβιστικός πρινένιος πριονιστός πριονοειδής
πρισματικός πρισματοειδής πριστή πριστός προαγοραστικός προαγωγικός
προαιρετικός προαιώνιος προακτέος προανακριτικός προαντιπροσωπευτικός
προβατίσιος προβατικός προβεβηκώς προβενσιανός προβηγκιανός προβλέψιμος
προβληματικός προβληματιστικός προβληματογόνος προβλητέος προβοκατόρικος
προβοσκιδοφόρος προβουλκανισμένος προγάμιος προγαμιαίος προγενέστερος
προγναθικός προγνωρίζων προγνωστικός προγνώμων προγονικός προγονολατρικός
προγραμματικός προγραμματιστικός προδημοκρατικός προδικαστικός προδοτικός
προδυναστικός προεγχειρητικός προεδρικός προεδροδημοκρατικός προειδοποιητικός
προεισπραττόμενος προεκλογικός προεκτοπιστικός προελληνικός προεμμηνορροϊκός
προεξαγγελτικός προεξοφλήσιμος προεξοφλητέος προεξοφλητικός προεξοφλητός
προεπενδυτικός προερωτικός προεφηβικός προεόρτιος προηγούμενος προθεατρικός
προθετικός προθυμότερος προθωρακικός προικιάτικος προικώος προκάρδιος προκάτ
προκαλυπτικός προκαπιταλιστικός προκαταβολικός προκατακλυσμιαίος
προκατασκευαστικός προκβαντικός προκεχωρημένος προκλασικός προκλητικός
προκλινής προκοίλης προκολομβιανός προκριματικός προκυκλικός προλεταριακός
προλογικός προμήκης προμεσημβρινός προμεταμοσχευτικός προμετωπίδιος
προμηθευτικός προμηθεϊκός προμινωικός προμνημονιακός προνοητικός προνοιακός
προνομιούχος προνομοθετημένος προνοσοκομειακός προξενικός προοδευτικός
προοπτικός προορατικός προοριστικός προπέρσινος προπαγανδιστικός
προπαρασκευαστικός προπαροξύτονος προπατορικός προπεμπτήριος προπεμπτικός
προπεριτοναϊκός προπερσινός προπερυσινός προπετής προπηλακιστικός προπληρωτέος
προπονητικός προσάνεμος προσάντης προσήλιος προσήλυτος προσήνεμος προσίστιος
προσαρμοσμένος προσαρμοστικός προσαρμόσιμος προσαυξητικός προσβάσιμος
προσβεβλημένος προσβλημένος προσβλητικός προσδιοριστικός προσδόκιμος
προσειλημμένος προσεκτικός προσεξουαλικός προσεταιριστικός προσεχής
προσηγορικός προσηλιακός προσηλυτίσιμος προσηλυτιστικός προσημασμένος προσηνής
προσθετικός προσθετός προσθιοπίσθιος προσιτός προσκαιρινός προσκείμενος
προσκυνηματικός προσλημμένος προσληπτέος προσληπτικός προσληφθείς προσοδοφόρος
προσοφθάλμιος προσπελάσιμος προσποιητικός προσποιητός προστήσας προστακτικός
προστατευόμενος προστατικός προσταχτικός προστερνίδιο προστιθέμενος
προσυλλογιστικός προσυμβατικός προσυμπτωματικός προσυμπτωματολογικός
προσυνταξιοδοτικός προσφιλής προσφυής προσφυγικός προσχηματικός προσχωματικός
προσχωτικός προσωδιακός προσωκρατικός προσωπιδοφόρος προσωπικός
προσωπογραφικός προσωποκεντρικός προσωπομετρικός προσωποπαγής προσωρινός
προτακτικός προτελευταίος προτελωνειακός προτεραίος προτερόχρονος
προτεταμένος προτιθέμενος προτιμησιακός προτιμητέος προτιμότερος προτρεπτικός
προυχοντικός προυχρόνιος προφέρσιμος προφανής προφαντός προφητικός προφορικός
προφυλακτικός προφυλαχτικός προφυματικός προχειρολόγος προχθεσινός
προχτεσινός προχωρητικός προχώ προψεσινός προωθητικός προωστήριος προωστικός
προϊστορικός προϋπάρχων προϋφιστάμενος πρυμήσιος πρυμιός πρυμνήσιος πρυμναίος
πρυμνόδετος πρυτανικός πρωθυπουργικός πρωθυπουργοκεντρικός
πρωθύστερος πρωινός πρωκτικός πρωκτολογικός πρωραίος πρωρατικός πρωσικός
πρωτάρης πρωτάρικος πρωταγωνιστικός πρωταπριλιάτικος πρωταρχικός
πρωτευουσιάνικος πρωτευουσιάνος πρωτεϊκός πρωτεϊνικός πρωτεϊνούχος πρωτινός
πρωτοβάθμιος πρωτοβυζαντινός πρωτογέννητος πρωτογενής πρωτογεωμετρικός
πρωτοελλαδικός πρωτοετής πρωτοκαιρίτικος πρωτοκλασάτος πρωτοκορινθιακός
πρωτομαγιάτικος πρωτομαρτιάτικος πρωτομινωικός πρωτονικός πρωτοπαθής
πρωτοποριακός πρωτοσέλιδος πρωτοσύστατος πρωτοτάξιδος πρωτοταγής πρωτοτόκος
πρωτοφανέρωτος πρωτοφανής πρωτοφανήσιμος πρωτοφόρετος πρωτοχρονιάτικος
πρωτυτερινός πρωτόβαλτος πρωτόβγαλτος πρωτόγεννος πρωτόγερος πρωτόγνωρος
πρωτόδικος πρωτόθετος πρωτόκλητος πρωτόκλιτος πρωτόλειος πρωτόλουβος
πρωτόπειρος πρωτόπιαστος πρωτότοκος πρωτότυπος πρωτόφαντος πρωτόχυτος
πρόβειος πρόβιος πρόγναθος πρόδηλος πρόδρομος πρόθυμος πρόνοος πρόξενος
πρόσγειος πρόσεδρος πρόσηβος πρόσθετος πρόσθιος πρόσκαιρος πρόστυλος πρόστυχος
πρόσφορος πρόσχαρος πρότερος πρότυπο:παραθετικά πρότυπο:παραθετικά
πρότυπος πρόχειλος πρόχειρος πρόωρος πρύμος πρώην πρώιμος πρώτιστος πτεροειδής
πτερυγοειδής πτερυγωτός πτερωτός πτερόεις πτηνοτροφικός πτητικός πτιλωτός
πτυκτός πτυχιακός πτυχιούχος πτυχωσιγενής πτυχωτός πτωματικός πτωτικός
πτωχικός πτωχοπροδρομικός πτωχός πτωχόταστος πυγαίος πυγμαίος πυγμαχικός
πυελοουρητηρικός πυθαγόρειος πυθικός πυκνογραμμένος πυκνοδομημένος
πυκνοκατοικημένος πυκνομετρικός πυκνωτικός πυκνόρρευστος πυκνός πυκνόφυλλος
πυλαίος πυλωρικός πυογόνος πυορροϊκός πυράντοχος πυρίκαυστος πυρίμαχος
πυραμιδικός πυραμιδοειδής πυραμιδωτός πυραμοειδής πυρασφαλιστικός πυραυλικός
πυραυλοφόρος πυργιώτικος πυργοεδής πυργοειδής πυργωτός πυρετικός πυρετογόνος
πυρηναϊκός πυρηνικός πυρηνοειδής πυρηνοκίνητος πυριγενής πυριτικός πυριτιούχος
πυροβατικός πυροβολικός πυρογενής πυρογραφικός πυροδοτικός πυροηλεκτρικός
πυροκλαστικός πυροκυτταρινικός πυρολατρικός πυρολιθικός πυρολυτικός
πυρομανής πυρομαχικός πυρομεταλλουργικός πυρομετρικός πυροπαθής πυροσβεστικός
πυροφορικός πυρπολικός πυρρόθριξ πυρρόξανθος πυρρός πυρρόχρους πυρφόρος
πυρόπληκτος πυρώδης πυώδης πωγωνάτος πωγωνοφόρος πόντιος πόσιμος πότιμος
πύξινος πύρινος πύρρειος πώρινος ράθυμος ρέζιγος ρέμπελος ρέστος ραβδοειδής
ραβδοφόρος ραβδωτός ραβινικός ραγδαίος ραγιάδικος ραδιενεργός ραδινός
ραδιογωνιομετρικός ραδιοηλεκτρικός ραδιοηλεκτρολογικός ραδιοθεραπευτικός
ραδιομετεωρολογικός ραδιοναυτιλιακός ραδιοπειρατικός ραδιοπυρηνικός
ραδιοτεχνικός ραδιοτηλεγραφικός ραδιοτηλεοπτικός ραδιοτηλεφωνικός ραδιοφαρικός
ραδιοφωνικός ραδιοχημικός ραδιοϊσοτοπικός ραδιούργος ραδιούχος ραιβοσκελής
ραιβός ραιτορομανικός ρακένδυτος ρακοφόρος ραμφοειδής ραμφοφόρος ραμφόστομος
ραπτικός ρασιοναλιστικός ρατσιστικός ραφινάτος ραφινέ ραφτικός ραχατλίδικος
ραχιτικός ραχοειδής ραψωδικός ρεαλιστικός ρεβανσιστικός ρεβιζιονιστικός
ρεζερβέ ρεθεμνιώτικος ρεθυμνιώτικος ρεμβώδης ρεμπέτικος ρεολογικός ρεοστατικός
ρεπουμπλικανικός ρετροσπεκτιβικός ρετρό ρετσινάτος ρευματικός ρευματοειδής
ρευματώδης ρευστομηχανικός ρευστοποιήσιμος ρευστός ρεφλέξ ρεφορμιστικός
ρηγματώδης ρημαδιακός ρηματικός ρηξιγενής ρηξικέλευθος ρητινικός ρητινοφόρος
ρητινώδης ρητορικός ρητός ρηχός ριγέ ριγανάτος ριγηλός ριγωτός ριζίτικο
ριζικάρης ριζικός ριζιμιός ριζοειδής ριζομορφικός ριζοσπαστικός ριζοτροπικός
ριζόμορφος ριζώδης ρικνός ριναίος ρινικός ρινολαρυγγικός ρινολογικός
ρινοσκοπικός ρινοφαρυγγικός ρινόφωνος ριπίταστος ριπαίος ριπιδίταστος
ριπιδωτός ριπιδόταστος ριχτός ριψοκίνδυνος ρογιάτικος ροδής ροδίτικος ροδαλός
ροδοειδής ροδοζυμωμένος ροδοζύμωτος ροδοκόκκινος ροδομάγουλος ροδομύριστος
ροδοπεριχυμένος ροδοστεφάνωτος ροδοστεφής ροδοστεφανωμένος ροδοψημένος
ροδόχρους ροδόχρωμος ροζ ροζέ ροζιάρης ροζιάρικος ροζιασμένος ρομ ρομανικός
ρομβικός ρομβοειδής ρομβωτός ρομποτικός ρομφαιοφόρος ροπαλοφόρος ροταριανός
ρουκετοφόρος ρουμάνικος ρουμανικός ρουμελιώτικος ρουμπινής ρουνικός ρουστίκ
ρουτινιέρικος ρουφηχτός ροφητός ρούσικος ρούσος ρυγχοειδής ρυγχοφόρος ρυγχωτός
ρυθμιστής ρυθμιστικός ρυμοτομικός ρυπαντικός ρυπαρός ρυπογόνος ρυτιδιασμένος
ρωμαίικος ρωμαιοκαθολικός ρωμαλέος ρωμανικός ρωμαντικός ρωμαϊκό ρωμαϊκός
ρωσομαθής ρωσόφιλος ρόδινος ρόδιος ρόπαλο ρώσικος σάπιος σάρκινος σέκος σένιος
σέρβικος σέρτικος σίγουρος σίτινος σίφνιος σαββατιάτικος σαββατιανός
σαββατογεννημένος σαβουρολάγνος σαγηνευτικός σαγκριώτικος σαδιστικός
σαθρός σαικσπηρικός σαιξπηρικός σακάτικος σακοειδής σακουλίσιος σακχαροειδής
σακχαρώδης σαλιάρης σαλικυλικός σαλπιγγικός σαλπιγγοειδής σαλός σαμαρειτικός
σαματατζίδικος σαμιακός σαμιώτικος σαμπανιζέ σανατορικός σανιδένιος
σανιδωτός σανιδόφραχτος σανσκριτικός σαντορινιός σαντορινιώτικος σαξ σαξονικός
σαουδικός σαπρογόνος σαπροφάγος σαπροφυτικός σαπρός σαπφείρινος σαπφειροειδής
σαπωνοειδής σαράφικος σαρακοστιάτικος σαρακοστιανός σαρακοφαγωμένος
σαρανταήμερος σαρδελοφάγος σαρδόνιος σαρκαστικός σαρκερός σαρκικός σαρκοβόρος
σαρκοειδής σαρκοφάγος σαρκοφαγικός σαρκωματώδης σαρκώδης σαρωτικός σασκίνης
σατινέ σατινένιος σατιρικός σατούρνιος σατράπικος σατραπικός σατυρικός
σαφέστερος σαφής σαφηνής σαφηνιστικός σαφρακιασμένος σαχλός σβέλτος σβεστός
σβουνοπασάλειφτος σβουριχτός σβωλιαστός σγουρομάλλης σγουρόμαλλος σγουρός
σεβασμιότατος σεβασμιώτατος σεβαστικός σεβαστός σεβνταλίδικος σειληνικός
σειραϊκός σειριακός σειρόδετος σεισμικός σεισμογενής σεισμογραφικός
σεισμολογικός σεισμομετρικός σεισμοπαθής σεισμόπληκτος σειστός σεκταριστικός
σελασφόρος σεληναίος σεληνιακός σεληνιούχος σεληνογραφικός σεληνοειδής
σεληνοτοπογράφος σεληνοτοπογραφικός σεληνοφώτιστος σεληνόφωτος σελωτός
σεμιναριακός σεμνολόγος σεμνοπρεπής σεμνός σεμνότυφος σεμπρικός σενεγαλέζικος
σενιάν σεντεφένιος σεξιστικός σεξολογικός σεξομανής σεξουαλικός σεξπιρικός
σεπτεμβριάτικος σεπτεμβριανός σεπτός σερέτικος σεραφικός σερβικός
σερβοκροατικός σερνάμενος σερνικοθήλυκος σερνικός σερπετός σερραίικος
σερσέμης σερσέμικος σεχταριστικός σηκωτός σημαδευτός σημαδιακός
σημαντικός σημαντικότατος σημασιολογικός σηματοτεχνικός σημειακός
σημειολογικός σημειωτέος σημειωτικός σημειωτός σημερινός σημερνός σημιτικός
σηρικός σηροτροφικός σησαμόπαστος σητειακός σηψαιμικός σηψιγόνος σθεναρός
σιαλαγωγός σιαλικός σιαλογόνος σιαλοφόρος σιαλώδης σιαμέζικος σιαμαίος
σιβηρικός σιβυλλικός σιγαλός σιγαλόφωνος σιγανός σιγηλός σιγμοειδής σιδεράτος
σιδεροκέφαλος σιδερωτός σιδερός σιδερόφραχτος σιδηροδέσμιος σιδηροδρομικός
σιδηροπαγής σιδηροπενικός σιδηρουργικός σιδηρούς σιδηρούχος σιδηρόφραχτος
σικ σικάτος σικέ σικελικός σιληνικός σιλοφόρος σιμιγδαλένιος σιμοτινός
σιμός σιναλεζικός σιναπούχος σιναϊτικός σινιέ σινικός σινοελληνικός
σινοσοβιετικός σιντεφένιος σιούτος σιροπιαστός σισύφειος σιτάρκης σιταγωγός
σιταρίσιος σιταροειδής σιταρόχρωμος σιτευτός σιτικός σιτοπαραγωγικός σιτοφόρος
σιφνέικος σιφνιώτικος σιφωνιάτικος σιχαμερός σιχασιάρης σιωνιστικός σιωπηλός
σκάνταλος σκάρτος σκέτος σκαδιώτικος σκαιός σκακιστικός σκαληνός σκαλιστικός
σκαλωτός σκαμπρόζικος σκαμπρόζος σκανδαλιάρης σκανδαλιάρικος σκανδαλιστικά
σκανδαλοθηρικός σκανδαλολογικός σκανδαλοπλόκος σκανδαλοποιός σκανδαλώδης
σκανδιναυϊκός σκανδόγλωσσος σκανταλιάρης σκανταλιάρικος σκαπτικός σκαπτός
σκαρφαλωτός σκαστός σκατένιος σκατιάρης σκατοκέφαλος σκατολογικός σκατοφάγος
σκαυϊκός σκαφευτικός σκαφιδωτός σκαφοειδής σκαφτικός σκαφτός σκεβρός
σκελετικός σκελετολογικός σκελετωμένος σκελετώδης σκεπαστικός σκεπαστός
σκεπτικός σκεπός σκερτσόζα σκερτσόζικος σκερτσόζος σκευαγωγός σκευομορφικός
σκηνικός σκηνογραφικός σκηνοθετικός σκηπτούχος σκιάθιος σκιαγραφικός σκιαζάρης
σκιερός σκιστός σκιτζίδικος σκιόφιλος σκιόφοβος σκιώδης σκληραγωγημένος
σκληρογόνος σκληροκέφαλος σκληροκόκαλος σκληρομετρικός σκληροπυρηνικός
σκληρυντικός σκληρωτικός σκληρόδερμος σκληρόκαρδος σκληρόπετσος σκληρός
σκληρόφλουδος σκληρόφυλλος σκληρόψυχος σκληρώδης σκοινένιος σκολιάτικος
σκολιωτικός σκοπελίτικος σκοπευμένος σκοπευτικός σκορβουτικός σκορδόπιστος
σκοροφαγωμένος σκορπιστός σκοταδερός σκοταδιστικός σκοτεινούτσικος σκοτεινός
σκοτικός σκοτοενεργειακός σκοτοϋλικός σκοτσέζικος σκοτωμένος σκουλάτος
σκουληκιάρικος σκουληκομυρμηγκοτρυποειδής σκουληκοφαγωμένος σκουντημένος
σκουροκόκκινος σκουροπράσινος σκουρόχρωμος σκουφάτος σκούρος σκυθικός
σκυλίσιος σκυλοδόντης σκυλοκέφαλος σκυλομούρης σκυλόψυχος σκυρωτός σκυφτός
σκωληκοφάγος σκωληκόβρωτος σκωπτικός σκωτικός σκωτσέζικος σκόπιμος σκόρπιος
σκύτινος σλάβικος σλαβικός σλαβόφιλος σλαβόφωνος σλαυόφιλος σλοβακικός
σμαράγδινος σμαραγδένιος σμαραγδοειδής σμαραγδόχρους σμηγματικός σμηγματογόνος
σμηκτικός σμικρός σμιλευτός σμιχτοφρύδης σμιχτός σμυριδεργατικός σμυριδικός
σμυρναϊκός σμυρνιώτικος σνομπ σνομπιστικός σοβαροφανής σοβαρός σοβαρότερος
σοβινιστικός σοβράνος σοδομικός σοδομιτικός σοκαριστικός σοκινιανός σοκολά
σοκολατής σοκολατούχος σολομώντειος σολωμικός σολώνιος σομφός σομφώδης σομόν
σορβικός σοροπιαστός σος σοσιαλδημοκρατικός σοσιαλιστικός σουβλερός σουβλιστός
σουδανέζικος σουδανικός σουηδέζικος σουηδικός σουλιώτικος σουλτανικός
σουμερικός σουμπρετίστικος σουνιτικός σουξεδιάρης σουρεαλιστικός σουρλωτός
σουσαμάτος σουσαμένιος σουσαμωτός σουσουδίστικος σουφικός σοφιστικός
σοφολογιώτατος σοφόκλειος σοφός σοϊλής σοϊλίδικος σοϊλίτικος σούκο σούμπιτος
σπάνιος σπάρτινος σπάταλος σπέσιαλ σπαγγοραμένος σπαγγοραμμένος σπαγκοραμμένος
σπαθοειδής σπαθωτός σπανιότατος σπανιότερος σπανός σπαρακτικός σπαραξικάρδιoς
σπαραχτικός σπαργωτός σπαρταριστός σπαρτιάτικος σπαρτιατικός σπαρτικός σπαρτός
σπασμωδικός σπασμώδης σπαστικός σπειροειδής σπειρωτός σπερματαγωγός
σπερματογόνος σπερματοδίκαιος σπερματοδόχος σπερματοκτόνος σπερματολογικός
σπερματοτοξικός σπερματοφάγος σπερματοφόρος σπερματούχος σπερμικός σπερμογόνος
σπερμολογικός σπερμοτοξικός σπερμοφάγος σπερμοφυής σπερμοφόρος σπερνός
σπηλαίος σπηλαιολογικός σπηλαιόβιος σπηλαιώδης σπιθαμιαίος σπιλωτικός
σπινθηροβόλος σπινθηρογραφικός σπιράλ σπιρτόζος σπιτίσιος σπιτικός σπλαγχνικός
σπλαγχνολογικός σπλαχνικός σπληνιάρης σπληνικός σπληνογραφικός σπληνολογικός
σπογγογενής σπογγοειδής σπογγώδης σπονδειακός σπονδυλικός σπονδυλωτός σπορ
σποριάρης σποριάρικος σπορογόνος σπορτίφ σπουδαίος σπουδαιοφανής σπουδασμένος
σπουδαχτικός σπυριάρης σπυρωτός σπόριμος σπόρκος σράναν στάσιμος στέρεος
σταβέντο σταβέτ σταγονομετρικός σταδιακός σταδιομετρικός σταθεροποιητικός
σταθμητός στακτός σταλακτικός σταλακτός σταλαχτός σταλινικός σταλινοειδής
σταμνόσχημος σταμπάτος σταμπωτός στανιαρισμένος στανικός σταράτος σταρένιος
σταρόχρωμος στασιαστικός στατικός στατιστικοποιήσιμος στατιστικός
σταυρανθής σταυρεπίστεγος σταυρικός σταυροαναστάσιμος σταυροειδής
σταυροπηγιακός σταυρωτός σταυρόσχημος σταυρότυπος σταυρώσιμος σταφιδικός
σταφυλοκοκκικός σταχτής σταχτερός σταχτοκίτρινος σταχτόχρωμος στεάτινος
στεατικός στεατοπυγικός στεατώδης στεγάσιμος στεγανωτικός στεγανός στεγαστικός
στεγνός στενάχωρος στενογραφικός στενοκέφαλος στενομέτωπος στενοπρόσωπος
στενόθωρος στενόκαρδος στενόμακρος στενόμυαλος στενόπορος στενός στενόστομος
στενόφυλλος στενόχωρος στενόψυχος στερεογραφικός στερεοελλαδίτικος
στερεοσκοπικός στερεοστατικός στερεοτακτικός στερεοτατικός στερεοτυπικός
στερεοφωτογραφικός στερεοχημικός στερεοχρωμικός στερεοϊσομερής στερεωτικός
στερεότυπος στερητικός στεριανός στερνίσιος στερνικός στερνοκλειδικός
στερνός στερρός στεφανηφόρος στεφανιαίος στεφανωτός στηθικός στηθοσκοπικός
στηρικτικός στητός στιβαρός στιγματικός στιγμιαίος στικτός στιλάτος
στιλιστικός στιλπνός στιπλ στιφρός στιφτός στιχηρός στιχογραφικός
στιχουργικός στοιβαχτός στοιχειακός στοιχειοθετικός στοιχειοχυτικός
στολοδρομικός στοματικός στοματογναθοπροσωπικός στοματολογικός στοματολόγος
στομαχικός στομφώδης στοργικός στουμπιστός στουμπουλός στουπένιος στοχαστικός
στράπλες στραβικός στραβοδίβολος στραβοκάνης στραβοκέφαλος στραβολαίμης
στραβοπόδης στραβός στραβόταστος στραγγαλιστικός στραγγιστικός στραγγιστός
στραταρχικός στρατεύσιμος στρατηγικός στρατιωτικός στρατογεμής στρατοκρατικός
στρατόκαβλος στρατόκαυλος στρεβλός στρεμματικός στρεπτοκοκκικός στρεπτός
στριγκός στριμμένος στριμωχτός στριμόκωλος στριφογυριστός στριφτός
στροβιλοειδής στροβοσκοπικός στρογγυλοπρόσωπος στρογγυλοφέγγαρος
στρογγυλόμακρος στρογγυλός στροντιούχος στρουμπουλός στρουμφολογικός
στρυφνός στρωματοποιημένος στρωτός στρόγγυλος στυγερός στυγνός στυπτικός
στυφούτσικος στυφτικός στυφός στωικός στωικότερος στωμύλος συβαριτικός
συγγενικός συγγνωστός συγγραφικός συγκάτοχος συγκαιρινός συγκαταβατικός
συγκατανευτικός συγκείμενος συγκεντρωμένος συγκεντρωτικός συγκεφαλαιωτικός
συγκινησιακός συγκινητικός συγκλίνων συγκλητικός συγκλονιστικός συγκοινωνιακός
συγκολλητικός συγκρίσιμος συγκρητικός συγκριτικός συγκρουσιακός συγκυβερνητέος
συγκυριακός συγχαρητήριος συγχρονικός συγχρονιστικός συγχυσμένος συγχυτικός
συγχωρητήριος συγχωρητικός συζευγμένος συζευκτικός συζητήσιμος συζητητικός
συζυγικός συθέμελος συκοφαντικός συλλήψιμος συλλαβικός συλλαβιστικός
συλλαβογραφικός συλλεκτικός συλλεχτικός συλληπτήριος συλλογικός συλλογισμένος
συλλυπητήριος συμέμελος συμβασιοκρατικός συμβασιούχος συμβατικός συμβατός
συμβιωτικός συμβολαιακός συμβολαιογραφικός συμβολικός συμβουλατορικός
συμμέτοχος συμμαζεμένος συμμαχικός συμμεταβλητός συμμετοχικός συμμετρικός
συμμορίτικος συμμοριτικός συμμοριόπληκτος συμμορφούμενος συμπαγής συμπαθής
συμπαθητικός συμπαντικός συμπαράγωγος συμπαραταξικός συμπεθερικός
συμπεριφορικός συμπεριφοριστικός συμπιεσμένος συμπιεστικός συμπιεστός
συμπλεκτικός συμπλεχτικός συμπληρωματικός συμπληρωτικός συμπολημερής
συμπονετικός συμποσιακός συμποσιαστικός συμποτικός συμπτωματικός
συμπυκνωτικός συμπότης συμπύρηνος συμφασικός συμφεροντολογικός συμφερτικός
συμφορητικός συμφραστικός συμφυής συμφυρματικός συμφυτικός συμφωνημένος
συμφωνόληκτος συμφωνόλητκος συμψηφιστικός συμψιφησθείς συνάλληλος συνένοχος
συναίτιος συναγωνιστικός συναδελφικός συναινετικός συναιρόμενος
συναισθητικός συνακόλουθος συναλλάξιμος συναλλαγματικός συναλλακτικός
συναπτικός συναπτός συναρμόδιος συναρπαστικός συναρτησιακός συνασπιστικός
συνδεσμικός συνδεσμοπλαστικός συνδετήριος συνδετικός συνδιαλλακτικός
συνδικαλιστικός συνδρομητικός συνδυαστικός συνεγγυητικός συνειδησιακός
συνειρμικός συνεκδοχικός συνεκτικός συνεπής συνεπικουρούμενος συνεπικρατών
συνεργατικός συνεργικός συνεσταλμένος συνεστραμμένος συνεταιρικός
συνετός συνεχής συνεχόμενος συνηθέστερος συνηθισμένος συνημμένος συνηχητικός
συνθετικός συνθηματικός συνθηματολογικός συννεφώδης συνοδευτικός συνοδικός
συνοικιακός συνολικός συνομήλικος συνομετρικός συνομοσπονδιακός
συνονόματος συνοπτικός συνοριακός συντάξιμος συνταγματικός συνταγογραφικός
συνταξιοδοτικός συνταρακτικός συνταραχτικός συνταχτικός συντελεστικός
συντεχνιακός συντηρητικός συντμημένο συντομογραφικός συντομότερος
συντριπτικός συντροφιαστός συντροφικός συνυπεύθυνος συνωμοσιολογικός
συνωνυμικός συνώνυμος συριακός συριανός συριγγώδης συριζαϊκός συριστικός
συρματένιος συρματόπλεκτος συρματόπλεχτος συρταρωτός συρτός συσσωρευτικός
συσταλτός συστατικός συστημένος συστηματικός συστημικός συστολική συστολικός
συσχετιστικός συφερτικός συφιλιδικός συφοριασμένος συχνός συχνότερος σφαγίτιδα
σφαδαστικός σφαιρικός σφαιροειδής σφακιώτικος σφαλερός σφαλιστός
σφαχτός σφηνοειδής σφηνωτός σφιγκτός σφικτός σφιχτοχέρης σφιχτόκωλος σφιχτός
σφοδρότερος σφουγγαράδικος σφραγιστικός σφραγιστός σφριγηλός σφυγμικός
σφυριχτός σχεδιαστικός σχεδιοποιημένος σχετικιστικός σχετικός σχετλιαστικός
σχιζοειδής σχιζοφρενής σχιζοφρενικός σχισματικός σχισμοειδής σχιστολιθικός
σχιστός σχοίνινος σχοινοβατικός σχοινοτενής σχολάζων σχολαστικός σχολιαστικός
σχωρεμένος σωβινιστικός σωκρατικός σωληνοειδής σωληνωτός σωματειακός
σωματικός σωματολογικός σωματομετρικός σωματοτρόπος σωματώδης σωρευτικός
σωροπυριτικός σωσίβιος σωστικός σωστός σωτήριος σωτηριολογικός σωφρονιστικός
σόλο σόλοικος σύγκαιρος σύγκορμος σύγχρονος σύκινος σύμμεικτος σύμμειχτος
σύμμορφος σύμπας σύμπηκτος σύμπλοκο σύμπλοκος σύμφορος σύμφυρτος σύμφυτος
σύνθετος σύννομος σύννους σύνολος σύνοφρυς σύντομος σύντονος σύνωρος σύξυλος
σύσπαστος σύσσωμος σύστοιχος σύψυχος σώος σώφρων τάλας τάλε κουάλε τάχιστος
τέλειος τέως τίμιος τίτσιρος ταβερνόβιος ταγγός ταγκός ταγμένος ταγματικός
ταζέτικος ταινιοειδής ταινιωτός ταινιόμορφος ταινιόπλεκτος ταιριαστός τακερός
τακτικός τακτικότερος τακτός ταλαίπωρος ταλαντευτικός ταλαντούχος ταλμουδικός
ταμαχκιάρης ταμειακός ταμειολογιστικός ταμιακός ταμιευτικός ταναγραίος τανικός
ταξιδιάρης ταξιδιάρικος ταξιδιωτικός ταξιδιώτικος ταξικός ταξινομικός
ταπεινός ταπεινόφρονας ταπεινόφρων ταραχοποιός ταραχώδης ταριχευμένος
ταριχευτός ταρσικός ταρτάρ τασμανικός ταστωτός ταστός ταταρικός ταυροειδής
ταυρόμορφος ταυτάριθμος ταυτογράμματος ταυτολογικός ταυτολόγος ταυτομερές
ταυτοπρόσωπος ταυτόαιμος ταυτόσημος ταυτόφωνος ταυτόχρονος ταυτώνυμος ταφικός
ταχινός ταχτικός ταχυβόλος ταχυγραφικός ταχυδακτυλουργικός ταχυδρομικός
ταχυεργός ταχυθάνατος ταχυκίνητος ταχυκαής ταχυμετρικός ταχυπόρος ταχύγλωσσος
ταχύπλοος ταχύπορος ταχύπους ταχύρρυθμος ταχύρυθμος ταχύς ταχύτερος
ταύρειος τεζαριστός τεθνεώς τεθωρακισμένος τεκμαρτός τεκμηριωτικός
τεκτονικός τεκτοπυριτικός τελειοθηρικός τελειοποιήσιμος τελειοποιημένος
τελειωμένος τελειωτικός τελεολογικός τελεσίδικος τελεσιγραφικός τελεστικός
τελετουργικός τελευταίος τελικός τελματικός τελματόβιος τελματώδης τελολογικός
τεμπέλης τεμπέλικος τεναγώδης τενεκεδένιος τενιστικός τεντωτός τεντώσιμος
τεξανός τεράστιος τερατογονικός τερατογόνος τερατοειδής τερατολογικός
τερατώδης τερβιούχος τερεφθαλικός τερματικός τερμιτοξενία τερμιτοφιλία
τερμιτόφιλος τερνερική τερνερικός τερπνός τερψίθυμος τερψιλαρύγγιο
τερώδης τεσσαράγωνος τεσσαρακάντουνος τεσσαρακονθήμερος τεσσαρακονταετής
τεσσαρακοστός τεσσεροκάντουνος τεταγμένος τετανικός τετανοειδής τεταρταίος
τεταρτογενής τεταρτοκυκλικός τετράβαθμος τετράβιβλος τετράγκωνος τετράγλωσσος
τετράγραμμος τετράγωνος τετράδιπλος τετράδραχμος τετράεδρος τετράθυρος
τετράιχνος τετράκαννος τετράκερος τετράκιλος τετράκλαστος τετράκλιμος
τετράκλιτος τετράκλωνος τετράκνημος τετράκολπος τετράκορφος τετράκρουνος
τετράκυκλος τετράκωπος τετράλεκτος τετράλιτρος τετράλοφος τετράμετρος
τετράμοιρος τετράμορος τετράμορφος τετράξανθος τετράξονος τετράοδος τετράορος
τετράπαχος τετράπεδος τετράπηχος τετράπλαστος τετράπλατος τετράπλεθρος
τετράπλοκος τετράποδος τετράπολος τετράπορος τετράπορτος τετράπρακτος
τετράπτερος τετράπτιλος τετράπτυχος τετράπτωτος τετράπυλος τετράπυργος
τετράριθμος τετράρραβδος τετράρριζος τετράρρινος τετράρριχτος τετράρρυθμος
τετράσειρος τετράσημος τετράσκαλμος τετράστεγος τετράστερος τετράστηλος
τετράστοιχος τετράστομος τετράστοος τετράστροφος τετράστυλος τετράσχιστος
τετράσωμος τετράτεκνος τετράτομος τετράτονος τετράτροπος τετράτροχος
τετράυνος τετράφαλος τετράφατσος τετράφθαλμος τετράφορος τετράφυλλος
τετράφωνος τετράφωτος τετράχειρος τετράχηλος τετράχορδος τετράχρονος
τετράχυτρος τετράχωρος τετράψηλος τετράψιδος τετράωρος τετράωτος τετραέμβολος
τετραΰφαντος τετρααιθυλικός τετρααιθυλιούχος τετρααλογονούχος
τετρααρσενικούχος τετραβάθμιδος τετραβάλβιδος τετραβαρής τετραβορικός
τετραβρωμικός τετραβρωμιούχος τετραβρωμιωμένος τετραγράμματος τετραγωνικός
τετραδάκτυλος τετραδάχτυλος τετραδιάτικος τετραδικός τετραδύστυχος
τετραεθνής τετραετής τετραετηρικός τετραζυγής τετραζωτούχος τετραθέσιος
τετραθειούχος τετρακάμαρος τετρακάναλος τετρακέρατος τετρακέφαλος
τετρακισχίλιοι τετρακλαδικός τετρακοσιοστός τετρακτινωτός τετρακυκλικός
τετρακόρωνος τετρακόσιοι τετρακόσοι τετρακόχλιος τετρακύλινδρος τετραλεκτικός
τετραμεθυλικός τετραμεθυλιούχος τετραμεθυλιωμένος τετραμελής τετραμερής
τετραμηνιάτικος τετραμηνιαίος τετραμιγής τετρανιτρικός τετρανιτρωμένος
τετρανύκτιος τετραξονικός τετραξωνικός τετραοίδιος τετραπάλαιστος τετραπάλαμος
τετραπέδιλος τετραπέρατος τετραπέταλος τετραπήχης τετραπίστονος
τετραπερασμένος τετραπηχυαίος τετραπλάσιος τετραπλέλικος τετραπληγικός
τετραπλούς τετραπλός τετραπολικός τετραπολιτειακός τετραπρόσωπος τετραπτέρυγος
τετραπτερύγιος τετραπυρολικός τετραπόταμος τετραπύργιος τετραπύρηνος
τετρασέλιδος τετρασέπαλος τετρασθενής τετρασκελής τετρασπίθαμος τετραστάδιος
τετραστρέμματος τετρασύλλαβος τετρασώματος τετρατάξιος τετρατομικός τετραυγής
τετραφάρμακος τετραφθορικός τετραφθοριούχος τετραφτέρουγος τετραφυής
τετραφωσφορικός τετραφωσφορούχος τετραφωσφορυλικός τετραφωσφορυλιούχος
τετραχλωρικός τετραχλωριούχος τετραχορδικός τετραψήφιος τετραωνυμικός
τετραϋδροφολικός τετραϋπόστατος τετραόργυιος τετραώνυμος τετραώροφος
τεφροειδής τεφρός τεφρώδης τεχνητός τεχνικοεφοδιαστικός τεχνικός τεχνοκρατικός
τεχνολογικός τεχνοοικονομικός τεχνουργικός τεχνόμορφος τζαμένιος τζαμπέ
τζαμωτός τζαναμπέτα τζαναμπέτης τζιμάνι τζιν τζιώτικος τζούφιος τηγανητός
τηκτικός τηλαυγής τηλεγραφικός τηλεκατευθυνόμενος τηλεκινητικός τηλεμετρικός
τηλεοπτικός τηλεορασόπληκτος τηλεπαθητικός τηλεπικοινωνιακός τηλεσκοπικός
τηλεφωνικός τηλεφωτογραφικός τηλεχειριζόμενος τηνιακός τιγροειδής τιμαλφής
τιμαριωτικός τιμητικός τιμοκρατικός τιμολογιακός τιμωρητέος τιμωρητικός
τιρκουάζ τιτάνιος τιτανικός τιτανιούχος τιτλομανής τιτλούχος τμηματικός
τμητός τοιχογραφικός τοιχοκολλητός τοκογλυφικός τοκοφόρος τοκοχρεολυτικός
τομέα τομαρένιος τομεακός τομεοποιημένος τομογραφικός τονικός τονούμενος
τοξικολογικός τοξικομανής τοξικοφόρος τοξικός τοξινικός τοξινοειδής
τοξοβόλος τοξοειδής τοξοφόρος τοξωτός τοπιακός τοπικιστικός τοπικός
τοπογραφικός τοποκεντρικός τοπομαχικός τοποστατικός τοπωνυμικός τορευτικός
τορνευτικός τορνευτός τοροειδής τορπιλικός τορπιλοβλητικός τορπιλοειδής
τοσοδούλης τοσοδούλικος τοσουλάκης τοσούλης τοσούτσικος τοτεμικός
τουλουμίσιος τουρανικός τουριστικός τουρκικός τουρκμενικός τουρκογενής
τουρκομαθής τουρκομερίτης τουρκομερίτικος τουρκοπατημένος τουρκοσπορίτης
τουρκόφωνος τουρλωτός τουρτουριάρης τουφωτός τοχαρικός τούλινος τούρκικος
τράγιος τρέχων τρήση τρίβηλο τρίβηλος τρίβραχυς τρίγαμος τρίγλυφος τρίγλωσσος
τρίδιπλος τρίδυμος τρίεδρος τρίεθνος τρίκλινος τρίκλιτος τρίκλωνος τρίκορφος
τρίλεπτος τρίμερος τρίμετρος τρίμηνος τρίμορφος τρίξιμο τρίπατος τρίπλευρος
τρίπρακτος τρίπραχτος τρίριχτος τρίσβαθος τρίσημος τρίστηλος τρίστιχος
τρίτομος τρίτροχος τρίφυλλος τρίφωνος τρίχινος τρίχορδος τρίχρονος τρίχρωμος
τραβεστί τραβηχτικός τραβηχτός τραγίσιος τραγανιστός τραγανός τραγελαφικός
τραγοειδής τραγοπόδαρος τραγοπώγων τραγουδιστικός τραγουδιστός τραγόμορφος
τρακαδόρικος τρακικοκωμικός τρακτερωτός τραμπουκικός τραμπούκικος τρανς
τρανσεξουαλικός τρανσπαράν τρανταχτός τρανός τραπατσούλης τραπεζικός
τραπεζιτικός τραπεζοασφαλιστικός τραπεζοειδής τραπεζομεσιτικός
τραπεζόεδρος τραυλός τραυλός τραυματικός τραυματολογικός τραχειακός
τραχειοτομικός τραχηλάτος τραχηλιαίος τραχηλικός τραχηλισμός τραχωματικός
τραχύς τραχύφωνος τρεις τρελούτσικος τρελός τρεμάμενος τρεμουλιάρης
τρεμουλιαστός τρεχάμενος τρεχάτος τρεχούμενος τρηματώδης τριάρμενος τριήμερος
τριαδικός τριαινοειδής τριακονθήμερος τριακονταετής τριακονταπλάσιος
τριακοσιοπλάσιος τριακοσιοστός τριακόσιοι τριακόσοι τριανδρικός τριαντάρης
τριανταφυλλένιος τριανταφυλλής τριανταφυλλί τριβρωμιούχος τριβόμενος τριγενής
τριγλώχινος τριγυρινός τριγωνικός τριγωνομετρικός τριεθνής τριετής τριζάτος
τρικάταρτος τρικέφαλος τρικαλινός τρικαλιώτικος τρικατάληκτος τρικινητήριος
τρικομματικός τρικούβερτος τρικυμιώδης τρικόρυφος τριλεκτικός τριμελής
τριμηνιαίος τριούσιος τριπάλαιστος τριπάλαστος τριπίθαμος τριπαλαιστιαίος
τριπλέλικος τριπλούς τριπλός τριπλότυπος τριπολικός τριπολιτσιώτικος
τρισάγιος τρισάθλιος τρισέγγονος τρισέλιδος τρισένδοξος τρισαποτελούμενος
τρισδιάστατος τρισευγενικός τρισευδαίμων τρισευτυχισμένος τρισεύγενος
τρισκότεινος τρισμέγιστος τρισμακάριστος τρισπήλαιος τρισπίθαμος
τρισυπόστατος τρισχειρότερος τρισχιδής τρισχιλιετής τρισόλβιος τρισύλλαβος
τριταίος τριτοβάθμιος τριτογενής τριτοετής τριτοκοσμικός τριτοπρόσωπος
τριτότοκος τριφασικός τριφτός τριφυλλόσχημος τριφωσφορυλικός τριφωσφορυλιούχος
τριχτός τριχωτός τριψήφιος τριώνυμος τριώροφος τρομακτικός τρομαχτικός
τρομοκρατικός τρομώδης τροπαιοφόρος τροπαιούχος τροπιδοειδής τροπικός
τρουλαίος τρουλλωτός τρουλοσκεπής τρουλωτός τροφαντός τροφικός τροφιμογενής
τροφολογικός τροχήλατος τροχαίος τροχαϊκός τροχιακός τροχιοδεικτικός
τροχοειδής τροχοφόρος τρυγλοδυτικός τρυπανοφόρος τρυπητός τρυπιοχέρης τρυφερός
τρωαδίτικος τρωαδικός τρωγλοδυτικός τρωικός τρωκτικός τρωτός τρόμπας τρύπιος
τσέτουλος τσέχικος τσίγκινος τσίλικος τσίτσιδος τσίφτικος τσαγανός τσαγκός
τσακιστός τσακωνικός τσακωτός τσακώνικος τσαμπατζής τσαμπουκαλίδικος τσαπαρλής
τσαπατσούλικος τσαρικός τσαχπίνης τσαχπίνικος τσεκουράτος τσευδός τσεχικός
τσεχοσλοβακικός τσιγαρισμένος τσιγαριστός τσιγγάνικος τσιγγούνης τσιγγούνικος
τσιγκούνικος τσικνισμένος τσιλιγκρός τσιμέντινος τσιμεντένιος τσιμενταρισμένος
τσιμπλιάρικος τσινιάρης τσιπλάκης τσιριγώτικος τσιριχτός τσιρλιάρης τσιτωτός
τσιφούτικος τσολιάδικος τσολιαδίστικος τσουρουφλιστός τσουρούκης τσουρούτικος
τσόχινος τυλιχτός τυλοφθόρος τυλώδης τυμπανιαίος τυμπανικός τυμπανογραφικός
τυνησιακός τυπικός τυπογραφικός τυποκλοπικός τυποκτόνος τυπολατρικός
τυπωτικός τυραννικός τυροκομικός τυροφάγος τυρρηνικός τυρφώδης τυφικός
τυφλός τυφοειδής τυχάρπαστος τυχαίος τυχοδιωκτικός τυχοδιωχτικός τυχών τωρινός
τόπλες τότε τόφαλος υάλινος υαλικός υαλογραφικός υαλοειδής υαλοσκεπής
υαλουργικός υαλουρονικός υαλωτός υαλόφρακτος υαλόφραχτος υαλώδης υβρεοφοβικός
υβριστικός υβός υγειονομικός υγιέστατος υγιής υγιεινός υγράλατος υγραεριοφόρος
υγρομετρικός υγροποιήσιμος υγροποιητικός υγροσκοπικός υγρόληκτος υγρόληχτος
υγρόφιλος υδάτινος υδαρής υδαταγωγός υδατικός υδατογραφικός υδατοδιαλυτός
υδατομετρικός υδατοσκοπικός υδατοστεγής υδατώδης υδραίικος υδραιμικός
υδραργυρούχος υδραυλικός υδρενεργειακός υδρευτικός υδροβιολογικός
υδρογονοκίνητος υδρογονούχος υδρογραφικός υδροδιαλυτός υδροδοτικός
υδροηλεκτρικός υδροθειικός υδροθειούχος υδροθεραπευτικός υδροθερμικός
υδροκίνητος υδροκεφαλικός υδροκηλικός υδροκριτικός υδροκυανικός υδρολογικός
υδρονομικός υδροπνευματικός υδροπονικός υδροσκοπικός υδροστατικός υδροστεγής
υδροτροπικός υδροφθορικός υδροφοβικός υδροφόρος υδροχαρής υδροχλωρικός
υδρωπικός υδρόβιος υδρόγειος υδρόφιλος υδρόφοβος υδρόχαρος υδρόψυκτος υιικός
υλικός υλιστικός υλοζωικός υλοποιήσιμος υλοτομικός υμενικός υμενοειδής
υμνητικός υμνογραφικός υμνολογικός υοειδής υπάλληλος υπάρξιμος υπέγγυος
υπέργειος υπέργηρος υπέρθερμος υπέρθυρος υπέρκαλος υπέρλαμπρος υπέρλεπτος
υπέρμαχος υπέρμετρος υπέρογκος υπέροχος υπέρπυκνος υπέρσοφος υπέρτατος
υπέρτονος υπέρυθρος υπέρφορτος υπήνεμος υπαίθριος υπαίτιος υπαγορευτικός
υπακτικός υπαλληλικός υπανάπτυκτος υπαρκτικός υπαρκτός υπαρξιακός υπαρξιστικός
υπεδάφιος υπεναντίος υπεξούσιος υπεράγαθος υπεράνθρωπος υπεράξιος υπεράριθμος
υπερένδοξος υπερήλικος υπερήλιξ υπερήμερος υπερήφανος υπερήψυλος υπεραγία
υπεραισθητικός υπεραιωνόβιος υπερακραίος υπεραλμυρός υπεραναλυτικός
υπεραρκετός υπερασπίσιμος υπερασπιστικός υπεραστικός υπερατλαντικός
υπεραυτόματος υπερβέβαιος υπερβαρύς υπερβατικός υπερβατός υπερβιταμινούχος
υπερβόρειος υπεργεωγραφικός υπεργλυκαιμικός υπερδεξιός υπερδισύλλαβος
υπερεκλεκτικός υπερεκτεταμένος υπερεξοπλισμένος υπερεπαρκής υπερευαίσθητος
υπερηχογραφικός υπερθεμελιωδέστατος υπερθετικός υπεριστορικός υπεριώδης
υπερκανονικός υπερκειμενικός υπερκινητικός υπερκομματικός υπερκονδύλιος
υπερμέτρωψ υπερμεγέθης υπερμοντέρνος υπερογδοντάχρονος υπεροπτικός
υπερουράνιος υπερούσιος υπερπλήρης υπερπολυτελής υπερπροσοντούχος
υπερπόντιος υπερρεαλιστικός υπερσιβηρικός υπερσυγκεντρωτικός υπερσυμβατικός
υπερσυμπαντικός υπερσυντηρητικός υπερσύγχρονος υπερτέλειος υπερτασικός
υπερτοπικός υπερτραφής υπερτροφικός υπερτυχερός υπερυδροφοβικός υπερυδρόφοβος
υπερφίαλος υπερφαλαγγίζων υπερφυής υπερφυσικός υπερφωσφορικός υπερφωτονικός
υπερωκεάνιος υπερωριακός υπερώιος υπερώριμος υπεύθυνος υπηρεσιακός υπναλέος
υπνοβατικός υπνολογικός υπνοφόρος υπνωτιστικός υποαλλεργικός υποατομικός
υποβαθμιστικός υποβλητικός υποβοηθητικός υποβολιμαίος υποβρυχιακός υποβρύχιος
υπογειωμένος υπογλυκαιμικός υπογλυκαιμικός υπογλώσσιος υπογνάθιος υπογόνιμος
υποδεέστερος υποδειγματικός υποδερμικός υποδόριος υποευτηκτοειδής υποθαλάμιος
υποθερμικός υποθετικός υποθηκευμένος υποθηκεύσιμος υποθηκικός υποκίτρινος
υποκείμενος υποκειμενικός υποκινήσιμος υποκινητικός υποκλείδιος υποκλινικός
υποκριτικός υποκύανος υπολειμματικός υπολειπόμενος υπολειτουργών υπολειφθής
υπολογιστικός υπομάζιος υπομικροσκοπικός υπομνηματικός υπομνηστικός
υπομονητικός υπονομευτικός υπονοούμενος υποουλικός υποπολλαπλάσιος υποσέλιδος
υποσελίδιος υποσημειακός υποστασιακός υποστατικός υποστηρικτικός υποστυλωτικός
υποσχετικός υποτακτικός υποτασικός υποταχτικός υποτελής υποτιμητικός
υποτροπιάζων υποτροπικός υποτυπώδης υπουργήσιμος υπουργικός υποφερτός
υποχείριος υποχθόνιος υποχλωριώδης υποχονδριακός υποχοντριακός υποχρεωτικός
υποχόνδριος υποχόντριος υποψήφιος υπωρόφιος υπόγειος υπόγλυκος υπόδικος
υπόθερμος υπόκαυστος υπόκωφος υπόλευκος υπόλογος υπόλοιπος υπόξανθος υπόξινος
υπόπυκνος υπόρρητος υπόσκαφος υπόσπονδος υπόστροφος υπόστυλος υπότονος
υπότροφος υπόφαιος υπόχρεος υπόχρεως υπόχρυσος υπόψυχρος υστεραίος υστερικός
υστερνός υστεροβυζαντινός υστερογενής υστεροελλαδικός υστερομεσαιωνικός
υστερόβουλος υστερότοκος υστερόχρονος υφάλμυρος υφέρπων υφέσιμος υφαντικός
υφαντουργικός υφαντός υφασμάτινος υφασματικός υφεσιακός υφηγητικός υψίκορμος
υψίφωνος υψηλόβαθμος υψηλόκορμος υψηλόμισθος υψηλός υψηλόσωμος υψηλότερος
υψηλόφωνος υψιπέτης υψιπετής υψιπετής υψιτενής υψομετρικός υψοφοβικός φάλτσος
φέρελπις φίλαθλος φίλανδρος φίλαρχος φίλαυτος φίλεργος φίλερις φίλιος φίλιππος
φίλτατος φίλυδρος φίλυπνος φίνος φίσκα φαβιανός φαγάδικος φαγανός φαγεδαινικός
φαγεσωρογόνος φαγοκυτταρικός φαγώσιμος φαεινός φαιδρολόγος φαιδρυντικός
φαινολικός φαινομενικός φαινομενολογικός φαιοκίτρινος φαιοχίτων φαιός
φακιδιάρης φακιρικός φακοειδής φαλαγγίτικος φαλαγγιτικός φαλαινοειδής
φαλακρός φαληρικός φαληριώτικος φαλλικός φαλλοκρατικός φαλλομορφικός
φαλλόσχημος φαλτσαριστός φαναριώτικος φανατικός φανατισμένος φανελένιος
φανερόγαμος φανερός φανταγμένος φανταιζί φανταρίστικος φαντασιακός
φαντασιόπληκτος φαντασιόπληχτος φαντασιώδης φαντασμένος φαντασμαγορικός
φανταχτερός φανταχτός φαντεζί φαντός φανφαρονίστικος φαραγγώδης φαραωνικός
φαρδουλός φαρδύς φαρδύτερος φαρικός φαρισαϊκός φαρμακερός φαρμακευτικός
φαρμακογνωστικός φαρμακοδυναμικός φαρμακοεπιδεσμικός φαρμακοκινητικός
φαρμακομανής φαρμακομύτης φαρμακοτεχνικός φαρμακόγλωσσος φαρμακώδης
φαρυγγικός φαρφουρένιος φασάτος φασίζων φασαριόζικος φασαριόζος φασικός
φασιστοειδής φασκιωμένος φασματικός φασματοσκοπικός φασματοφωτομετρικός
φατνιακός φατνωτός φατριακός φατριαστικός φαυλεπίφαυλος φαυλοκρατικός
φαφλατάδικος φαφούτικος φαύλος φαύνος φεβρουαριάτικος φεβρουαριανός
φεγγαρίσιος φεγγαριάτικος φεγγαροντυμένος φεγγαροπρόσωπος φεγγαροστολισμένος
φεγγαρόλουστος φεγγαρόφωτος φεγγερός φεγγοβόλος φεγγριστός φειδιακός φειδωλός
φελιαστός φελλάτος φελλένιος φελλωτός φελλώδης φελπένιος φελπεδένιος
φενακιστικός φεντεραλιστικός φεουδαλικός φεουδαρχικός φερέγγυος φερέοικος
φερώνυμος φετινός φετιχικός φετιχιστικός φευγάτος φευγαλέος φευκτός
φθαλικός φθαρτικός φθαρτός φθειρικός φθειροκτόνος φθηνιάρικος φθηνούτσικος
φθινοπωριάτικος φθινοπωρινός φθισικός φθογγικός φθογγογραφικός φθογγολογικός
φθορίζων φθοριούχος φθοριωμένος φθοροποιός φιαλοειδής φιαλωτός φιγουράτος
φιδένιος φιδίσιος φιδωτός φιλάλληλος φιλάνθρωπος φιλάργυρος φιλάρεσκος
φιλάσθενος φιλέκδικος φιλέορτος φιλέραστος φιλέρημος φιλήδονος φιλήκοος
φιλίστωρ φιλαλήθης φιλανδέζικος φιλανδικός φιλανθρωπικός φιλαπόδημος
φιλειρηνιστικός φιλεκπαιδευτικός φιλελεύθερος φιλελληνικός φιλεπιστήμων
φιλεύσπλαγχνος φιλεύσπλαχνος φιλικός φιλιππικός φιλιωμένος φιλμικός
φιλοαγροτικός φιλοβαλκανικός φιλοβασιλικός φιλοδίκαιος φιλοδασικός φιλοδυτικός
φιλοζωικός φιλοθεάμων φιλοκατήγορος φιλοκερδής φιλοκυβερνητικός φιλολακωνικός
φιλολογικός φιλομαθής φιλομειδής φιλοπερίεργος φιλοπεριβαλλοντικός φιλοπράγμων
φιλοπόλεμος φιλοσοβιετικός φιλοσοφημένος φιλοσοφικός φιλοτελής φιλοτελικός
φιλοτουρκικός φιλοφρονητικός φιλοχρήματος φιλτραρισμένος φιλωτίτικος φιλόδικος
φιλόζωος φιλόθεος φιλόθρησκος φιλόκαλος φιλόκροτος φιλόμουσος φιλόνομος
φιλόπατρις φιλόπονος φιλόπρωτος φιλόπτωχος φιλόστοργος φιλότεκνος φιλότεχνος
φιλόφρων φιλόχριστος φιλόψογος φιλόψυχος φιλύποπτος φιμέ φινετσάτος
φινλανδικός φιννικός φιξ φιστικής φιστικωμένος φκιασιδωμένος φλαμανδικός
φλασκωτός φλεβαριάτικος φλεβικός φλεβοκομβικός φλεβοτομικός φλεβώδης
φλεγματώδης φλεγμονικός φλεγμονώδης φλογάτος φλογερός φλογιστικός φλογοβόλος
φλογωτικός φλογόλευκος φλογώδης φλοιακός φλοιικός φλοιώδης φλοκάτος φλοκιαστός
φλοράλ φλου φλουδερός φλυκταινώδης φλωρεντινός φλωρινιώτικος φλωροκαπνισμένος
φλύαρος φοβερός φοβητσιάρης φοβητσιάρικος φοβικός φοιβόληπτος φοινικικός
φοιτητικός φολιδωτός φολκλορικός φονικός φορειοφόρος φορετός φορητός
φοροδοτικός φοροεισπρακτικός φοροελεγκτικός φορολογήσιμος φορολογητέος
φορομπηχτικός φοροτελής φοροτεχνικός φορσέ φορτηγός φορτικός φορτσάτος
φορτωτικός φουκαριάρης φουκαριάρικος φουλ φουλαριστός φουντωτός φουριόζικος
φουρνιστός φουρνιώτικος φουσκομάγουλος φουσκωτός φουτουριστικός φράγκικος
φρέσκος φραντσέζικος φραξιονιστικός φρασεολογικός φραστικός φρεζάτος φρενήρης
φρενικός φρενιτικός φρενιτιώδης φρενοβλαβής φρενολογικός φρενοπαθής
φρεσκοβαμμένος φρεσκογυαλισμένος φρεσκοκομμένος φρεσκοπασαλειμμένος
φρεσκοψημένος φρικαλέος φρικιαστικός φρικτός φρικώδης φριχτός φρονηματιστικός
φρουριακός φροϋδικός φρούδος φρυγανισμένος φρυγανώδης φρυγικός φρυδάτος
φρόνιμος φτενός φτενόφλουδος φτεροπόδαρο φτεροπόδαρος φτερωτός φτηνιάρικος
φτηνός φτιασιδωμένος φτιαστός φτιαχτός φτυστός φτωχικός φτωχομεσαίος
φτωχούλα φτωχούλης φτωχούτσικος φτωχός φτωχότερος φυγοκεντρικός φυγοπόλεμος
φυγόκοσμος φυγόμαχος φυγόποινος φυγόπονος φυκόστρωτος φυλακτικός φυλετικός
φυλλοειδής φυλλοξηρικός φυλλοπυριτικός φυλλοσκεπής φυλλοστρωμένος φυλλοφάγος
φυλλώδης φυλογενετικός φυλογονικός φυμέ φυματικός φυματιολογικός φυματιώδης
φυρός φυσητικός φυσητός φυσικοθεραπευτικός φυσικομαθηματικός φυσικοχημικός
φυσιογνωμικός φυσιογνωστικός φυσιογραφικός φυσιοδιφικός φυσιοθεραπευτικός
φυσιολατρικός φυσιολογικός φυτευτικός φυτευτός φυτικός φυτογεωγραφικός
φυτολογικός φυτοπαθολογικός φυτοτεχνικός φυτοφάγος φυτοφαγικός φυτρωτικός
φωνακλάς φωνακλού φωνακλούδικο φωναχτός φωνηεντικός φωνηεντόληκτος φωνηματικός
φωνητικός φωνογραφικός φωνοκινητικός φωνοληπτικός φωνολογικός φωνομετρικός
φωστηρικός φωσφορίζων φωσφοριζέ φωσφορικός φωσφορομολυβδαινικός φωσφορούχος
φωσφορυλιούχος φωταγωγικός φωτεινός φωτεινότερος φωτερός φωτιοκαμένος
φωτοακουστικός φωτοαντιγραφικός φωτοβολταϊκό φωτοβολταϊκός φωτοβόλος φωτογενής
φωτογραφικός φωτογόνος φωτοδιαπερατός φωτοευαίσθητος φωτοευπαθής
φωτοκαταλυτικός φωτομετρικός φωτομηχανικός φωτοοπτικός φωτορεαλιστικός
φωτοτηλεγραφικός φωτοτυπικός φωτοφανής φωτοφοβικός φωτοφόρος φωτοχημικός
φωτόφοβος χάλκινος χάρτινος χάσικος χέρσος χίλιοι χίπικος χαβανέζικος χαδιάρης
χαζοβιόλης χαζοχαρούμενος χαζούλης χαζός χαιρέκακος χαιρετιστήριος
χαλαζόπληχτος χαλαρωτικός χαλαρός χαλδαϊκός χαλεπός χαλικερός χαλικοστρωμένος
χαλικόστρωτος χαλικώδης χαλκέντερος χαλκευτικός χαλκιδιώτικος χαλκογραφικός
χαλκοπλαστικός χαλκοπράσινος χαλκοπόδαρος χαλκοστρωμένος χαλκοτυπικός
χαλκοφόρος χαλκούς χαλκούχος χαλκωματένιος χαλκόδετος χαλκόξανθος χαλκόστρωτος
χαλύβδινος χαμάλικος χαμερπής χαμηλοβλέφαρος χαμηλοθώρα χαμηλοθώρης
χαμηλοτάκουνος χαμηλούτσικος χαμηλόβαθμος χαμηλόμισθος χαμηλόρρυθμος χαμηλός
χαμηλόφωνος χαμιτικός χαμογελαστός χαναανικός χαναανιτικός χανιώτικος
χαοτικός χαρίεις χαρακτηριστικός χαρακτικός χαρακωτός χαραμοφάγος χαρισάμενος
χαριστικός χαριτολόγος χαριτόβρυτος χαριτόμορφος χαριτόπλαστος χαρμόσυνος
χαρτένιος χαρτεμπορικός χαρτζιλικωμένος χαρτογραφικός χαρτομανής
χαρτοπαιχτικός χαρτοσημασμένος χαρτόδετος χαρτώος χαρωπός χασάπικος χασεδένιος
χασμουριάρης χατιρικός χαυνωτικός χαχόλικος χαϊδευτικός χαύνος χαώδης
χειλεόφωνος χειλικός χειλοδοντικός χειλόφωνος χειμέριος χειμαρρώδης χειμερινός
χειμωνικός χειράφετος χειραγωγήσιμος χειραλικός χειριδωτός χειριστικός
χειρογραφικός χειροδύναμος χειροκίνητος χειροπιαστός χειροποίητος
χειροτονημένος χειρουργήσιμος χειρουργικός χειρωνακτικός χειρόγραφος
χελίσιος χελωνίσιος χελωνιάρης χελωνοειδής χεροδύναμος χεροκάμωτος χερουβικός
χετιτικός χηλοειδής χημειοθεραπευτικός χημειοσυνθετικός χημικοθεραπευτικός
χημικός χηνίσιος χηράμενος χηρευάμενος χηρεύων χθαμαλός χθεσινοβραδινός
χθόνιος χιαστός χιλιάκριβος χιλιάρικος χιλιανός χιλιαπλάσιος χιλιοειπωμένος
χιλιοφορεμένος χιλιοχρονίτικος χιλιόφωνος χιλιόχρονος χιμαιρικός
χιονάτος χιονένιος χιονοβόλος χιονοδρομικός χιονοσκέπαστος χιονοσκεπής
χιονόλευκος χιονόμαλλος χιονώδης χιουμοριστικός χιτλερικός χιόνι χιώτικος
χλεμπονιάρης χλεμπονιασμένος χλευασμένος χλευαστικός χλιαρός χλιδάτος χλιος
χλομός χλωμός χλωρικός χλωριούχος χλωροφορμικός χλωρός χνουδάτος χνουδερός
χοίρειος χοίρινος χοανοειδής χοηφόρος χοιραδικός χοιρινός χολαιμικός
χολερικός χολερόβλητος χοληδόχος χοληφόρος χολιαστικός χολιγουντιανός χολικός
χονδρεμπορικός χονδρικός χονδροειδής χονδροπεταλωμένος χονδροποιός χονδρός
χοντραλεσμένος χοντρικός χοντροαλεσμένος χοντρογούρουνο χοντροδουλεμένος
χοντροκαύκαλος χοντροκομμένος χοντροκόκαλος χοντροκώλα χοντρομπαλάς
χοντρουλός χοντροφτιαγμένος χοντρούλης χοντρούτσικος χοντρόκοκκος χοντρόμυαλος
χοντρός χοντρόφλουδος χοντρόφωνος χορειακός χορευτικός χορευτός χορηγητικός
χορικός χοριοειδής χορογραφικός χοροπηδηχτός χοροστατικός χοροστατών χορτάτος
χορταστικός χορτοκοπτικός χορτολιβαδικός χορτοφάγος χορωδιακός χουλιγκανικός
χουντικός χουντοβασιλικός χουχουλιάρης χουχουλιάρικος χοϊκός χούρδος χρήσιμος
χρεοκοπικός χρεωλυτικός χρεωστικός χρηματικός χρηματισμένος χρηματιστηριακός
χρηματοδοτικός χρηματοκαπιταλιστικός χρηματολογικός χρηματοοικονομικός
χρησάμενος χρησιμοθηρικός χρησιμοκρατικός χρησιμοποιήσιμος χρησμολόγος
χρηστήριος χρηστικός χρηστοήθης χρηστός χριστεπώνυμος χριστιανικός
χριστουγεννιάτικος χριστός χρονίζων χρονιάρης χρονιάρικος χρονιάτικος χρονικός
χρονογραφικός χρονολογικός χρονομεριστικός χρονομετρικός χρονορρυθμιστικός
χρυσαφένιος χρυσαφής χρυσελεφάντινος χρυσεπίβαπτος χρυσοΰφαντος χρυσοθηρικός
χρυσοκίτρινος χρυσοκόκκινος χρυσοκόλλητος χρυσομάλλης χρυσομάλλικος
χρυσοποίκιλτος χρυσοποικιλτικός χρυσοπράσινος χρυσοπόρφυρος χρυσοστεφάνωτος
χρυσοστόλιστος χρυσοφόρος χρυσοχοϊκός χρυσωπός χρυσωτικός χρυσωτός χρυσόδετος
χρυσόμαλλος χρυσόξανθος χρυσόπλεχτος χρυσός χρυσόφτερος χρυσόφωνος χρωματικός
χρωματιστός χρωματογόνος χρωματοφόρος χρωμικός χρωμιούχος χρωμογόνος
χρωμολιθογραφικός χρωμοσφαιρικός χρωμοσωμικός χρωμοφόρος χρως χρωστικός
χτίκιασμα χτεσινοβραδινός χτεσινός χτικιάρης χτικιάρικος χτιστός χτυπητός
χυδαιόγλωσσος χυλώδης χυμογόνος χυμώδης χυτός χωλός χωμάτινος χωματένιος
χωνευτικός χωνευτός χωνοειδής χωρητικός χωριάτικος χωρικός χωριστικός χωριστός
χωρονομικός χωροταξικός χωροφυλακίστικος χωστός χόνδρινος ψάθινος ψαθυρός
ψαλιδισμένος ψαλιδιστός ψαλιδοειδής ψαλιδωτός ψαλμικός ψαλμωδικός ψαλτικός
ψαμμιακός ψαμμιτικός ψαμμόφιλος ψαμμώδης ψαράδικος ψαρικός ψαροφάγος ψαρωτικός
ψαρός ψαφαρός ψαχνός ψαχουλευτός ψεδνός ψειριάρης ψειριάρικος ψεκτός ψελλός
ψεσινός ψευδής ψευδαισθητικός ψευδαληθής ψευδανθρακικός ψευδαργυρικός
ψευδαρμόνιος ψευδεπίγραφος ψευδεπιστημονικός ψευδοδιλημματικός
ψευδολόγιος ψευδολόγος ψευδοπαράλληλος ψευδοσοφικός ψευδοτυχαίος ψευδόθεος
ψευδόφιλος ψευδώνυμος ψευτολόγιος ψευτοφαγωμένος ψεύδορκος ψεύτικος ψηλαφητός
ψηλοκρεμαστός ψηλομύτης ψηλοτάβανος ψηλοτάκουνος ψηλόλιγνος ψηλόπλωρος
ψηλός ψηλόσωμος ψηλότερος ψητός ψηφιακός ψηφιδοφόρος ψηφιδωτός ψηφοθηρικός
ψιλοάθεος ψιλοκαμωμένος ψιλοκομμένος ψιλωτικός ψιλός ψιλόφλουδος ψιχαλιστός
ψιψιριάρης ψοφοδεής ψοφώδης ψυγείο ψυγμένος ψυκτικός ψυχαγωγικός
ψυχαναληπτικός ψυχαναλυτικός ψυχανώμαλος ψυχασθενής ψυχασθενικός ψυχεδελικός
ψυχιατροδικαστικός ψυχικάρης ψυχικός ψυχοαναληπτικός ψυχοβιολογικός ψυχοβλαβής
ψυχογενής ψυχογενετικός ψυχογραφικός ψυχοδιαγνωστικός ψυχοδιανοητικός
ψυχοδραματικός ψυχοδραστικός ψυχοδυναμικός ψυχοθεραπευτικός ψυχοκινητικός
ψυχοκοινωνιολογικός ψυχοκτόνος ψυχοληπτικός ψυχολογικός ψυχομετρικός
ψυχονοητικός ψυχοπαθής ψυχοπαθολογικός ψυχοπαιδαγωγικός ψυχοπλάνος
ψυχοπνευματικός ψυχοπονιάρης ψυχοπονιάρικος ψυχοσωματικός ψυχοσωτήριος
ψυχοτονικός ψυχοτρόπος ψυχοφθόρος ψυχοφυσικός ψυχοφυσιολογικός ψυχοχημικός
ψυχραμένος ψυχραντικός ψυχρομετρικός ψυχροπολεμικός ψυχρούτσικος ψυχρόαιμος
ψυχρόφιλος ψυχτικός ψυχωσικός ψυχωτικός ψυχωφελής ψυχόπονος ψωραλέος ψωριάρης
ψωριασικός ψωροειδής ψωροπερήφανος ψωροφιλότιμος ψόφιος ψύχραιμος ωαγωγικός
ωθητικός ωκεάνιος ωκεανογραφικός ωκεανολογικός ωκεανοπλοϊκός ωκυτόκιος
ωκύπους ωκύπτερος ωλεκράνιος ωλεκρανικός ωλενικός ωμιαίος ωμικός ωμοβόρος
ωμοφάγος ωμός ωογόνος ωοειδής ωοζωοτόκος ωοθηκικός ωοτόκος ωοφάγος ωοφόρος
ωραιοπαθής ωραιόπαθος ωραιόπλουμος ωραιότατος ωραιότερος ωριαίος ωρισμένος
ωριός ωρολογιακός ωρολόγιος ωρομίσθιος ωσμωτικός ωστικός ωτακουστικός
ωτιαίος ωτικός ωτοειδής ωτολογικός ωτορινολαρυγγολογικός ωφέλιμος
ωφελιμοθηρικός ωχρινοτρόπος ωχροκίτρινος ωχροκόκκινος ωχρομέλας ωχροπρόσωπος
ωχρόλευκος ωχρός ωχρόφαιος ωώδης όλβιος όλκιμος όλος όμαιμος όμβριος όμοιος
όμορφος όνειος όξινος όρθιος όσιος όφκαιρος όψια όψιμος ύπανδρος ύπατος
ύπουλος ύπτιος ύστατος ύστερος ύψιστος ώριμος ώριος ἀγκυλωτός ἀκαταμέτρητος
ἄπειρος ἄτροπος ἐλαφρός ἐνεστώς ἐνυπόστατος ἔναυλος ἥττων ἰσχυρός ἵστωρ
""".split())
|
//
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Sep 17 2017 16:24:48).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2015 by Steve Nygard.
//
#import "ALTask.h"
#import "ALConnectionManagerDelegate-Protocol.h"
@class ALPostbackHTTPRequest, NSString;
@protocol ALPostbackDelegate;
@interface ALTaskDispatchPostback : ALTask <ALConnectionManagerDelegate>
{
ALPostbackHTTPRequest *_request;
unsigned long long _executionQueue;
id <ALPostbackDelegate> _delegate;
}
@property(retain, nonatomic) id <ALPostbackDelegate> delegate; // @synthesize delegate=_delegate;
@property(nonatomic) unsigned long long executionQueue; // @synthesize executionQueue=_executionQueue;
@property(retain, nonatomic) ALPostbackHTTPRequest *request; // @synthesize request=_request;
- (void).cxx_destruct;
- (id)key;
- (_Bool)connectionVia:(id)arg1 requiresResponseForRequest:(id)arg2;
- (void)connectionVia:(id)arg1 didFailWith:(long long)arg2;
- (void)connectionVia:(id)arg1 didSucceedWith:(long long)arg2 responseBody:(id)arg3;
- (void)run;
- (id)initWithRequest:(id)arg1 executionQueue:(unsigned long long)arg2 delegate:(id)arg3 sdk:(id)arg4;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
|
/**
* Configure your Gatsby site with this file.
*
* See: https://www.gatsbyjs.org/docs/gatsby-config/
*/
require("dotenv").config();
const useStrapi = process.env.GATSBY_USE_STRAPI;
description_string =
"Learn everything you need to know to use the @coursemaker/gatsby-theme-coursemaker \n" +
"Including how to setup gated content and payments.";
cta_description_string =
"There has never been an easier way to make an online course. \n" +
"And it's free.";
module.exports = {
siteMetadata: {
title: "CourseMaker Academy",
owner: {
email: "[email protected]",
},
landing_page: {
title_and_description: {
title: "The CourseMaker Academy (open-source demo)",
description: description_string,
},
primary_button: {
text: "View Courses",
color: "green",
text_color: "white",
},
cta_section: {
title: "Everything you need to use CourseMaker's Tools",
description: cta_description_string,
},
cta_button: {
text: "View Courses",
color: "green",
text_color: "white",
},
},
stripe_public_key: "pk_test_TYooMQauvdEDq54NiTphI7jx",
},
plugins: [
{
resolve: `@coursemaker/gatsby-theme-coursemaker`,
options: {
// contentPath: "schoolMDX",
// coursesPath: "schoolMDX/courses",
// authorsPath: "schoolMDX/authors",
useStrapi: useStrapi,
},
},
],
};
|
import datetime
from decimal import Decimal
from json import JSONDecodeError
from unittest.mock import Mock, patch
import pytest
from django.core.exceptions import ValidationError
from django.test import override_settings
from prices import Money, TaxedMoney
from requests import RequestException
from ....checkout.fetch import (
CheckoutInfo,
fetch_checkout_info,
fetch_checkout_lines,
get_valid_shipping_method_list_for_checkout_info,
)
from ....checkout.utils import add_variant_to_checkout
from ....core.prices import quantize_price
from ....core.taxes import TaxError, TaxType
from ....product.models import Product, ProductType
from ...manager import get_plugins_manager
from ...models import PluginConfiguration
from .. import (
META_CODE_KEY,
META_DESCRIPTION_KEY,
AvataxConfiguration,
TransactionType,
_validate_adddress_details,
api_get_request,
api_post_request,
generate_request_data_from_checkout,
get_cached_tax_codes_or_fetch,
get_order_request_data,
get_order_tax_data,
taxes_need_new_fetch,
)
from ..plugin import AvataxPlugin
@pytest.mark.vcr()
@pytest.mark.parametrize(
"with_discount, expected_net, expected_gross, taxes_in_prices",
[
(True, "12.20", "15.00", True),
(False, "24.39", "30.00", True),
(True, "15.00", "18.45", False),
(False, "30.00", "36.90", False),
],
)
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_line_total(
with_discount,
expected_net,
expected_gross,
taxes_in_prices,
discount_info,
checkout_with_item,
address,
ship_to_pl_address,
site_settings,
monkeypatch,
shipping_zone,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
site_settings.company_address = address
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
line = checkout_with_item.lines.first()
product = line.variant.product
product.metadata = {}
product.charge_taxes = True
product.save()
product.product_type.save()
discounts = [discount_info] if with_discount else None
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, discounts, manager)
checkout_line_info = lines[0]
total = manager.calculate_checkout_line_total(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
discounts,
)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(
net=Money(expected_net, "USD"), gross=Money(expected_gross, "USD")
)
@pytest.mark.vcr()
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_order_line_total(
order_line,
address,
ship_to_pl_address,
shipping_zone,
site_settings,
monkeypatch,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save(update_fields=["company_address"])
order = order_line.order
order.shipping_address = ship_to_pl_address
order.shipping_method = shipping_zone.shipping_methods.get()
order.save(update_fields=["shipping_address", "shipping_method"])
variant = order_line.variant
product = variant.product
product.metadata = {}
product.charge_taxes = True
product.save()
product.product_type.save()
channel = order_line.order.channel
channel_listing = variant.channel_listings.get(channel=channel)
net = variant.get_price(product, [], channel, channel_listing)
unit_price = TaxedMoney(net=net, gross=net)
order_line.unit_price = unit_price
total_price = unit_price * order_line.quantity
order_line.total_price = total_price
order_line.save()
total = manager.calculate_order_line_total(
order_line.order,
order_line,
variant,
product,
)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(net=Money("30.00", "USD"), gross=Money("36.90", "USD"))
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_order_line_total_order_not_valid(
order_line,
address,
site_settings,
monkeypatch,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save(update_fields=["company_address"])
variant = order_line.variant
product = variant.product
product.metadata = {}
product.charge_taxes = True
product.save()
product.product_type.save()
order = order_line.order
channel = order.channel
channel_listing = variant.channel_listings.get(channel=channel)
net = variant.get_price(product, [], channel, channel_listing)
unit_price = TaxedMoney(net=net, gross=net)
order_line.unit_price = unit_price
total_price = unit_price * order_line.quantity
order_line.total_price = total_price
order_line.save()
total = manager.calculate_order_line_total(
order_line.order,
order_line,
variant,
product,
)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(net=Money("0.00", "USD"), gross=Money("0.00", "USD"))
@pytest.mark.vcr
@pytest.mark.parametrize(
"with_discount, expected_net, expected_gross, voucher_amount, taxes_in_prices",
[
(True, "22.32", "26.99", "0.0", True),
(True, "21.99", "27.74", "5.0", False),
(False, "41.99", "51.19", "0.0", False),
(False, "31.51", "38.99", "3.0", True),
],
)
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_total_uses_default_calculation(
with_discount,
expected_net,
expected_gross,
voucher_amount,
taxes_in_prices,
checkout_with_item,
product_with_single_variant,
discount_info,
shipping_zone,
address,
ship_to_pl_address,
site_settings,
monkeypatch,
plugin_configuration,
non_default_category,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.save()
site_settings.company_address = address
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
voucher_amount = Money(voucher_amount, "USD")
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.discount = voucher_amount
checkout_with_item.save()
line = checkout_with_item.lines.first()
product = line.variant.product
product.metadata = {}
manager.assign_tax_code_to_object_meta(product.product_type, "PC040156")
product.save()
product.product_type.save()
product_with_single_variant.charge_taxes = False
product_with_single_variant.category = non_default_category
product_with_single_variant.save()
discounts = [discount_info] if with_discount else None
checkout_info = fetch_checkout_info(checkout_with_item, [], discounts, manager)
add_variant_to_checkout(checkout_info, product_with_single_variant.variants.get())
lines = fetch_checkout_lines(checkout_with_item)
total = manager.calculate_checkout_total(checkout_info, lines, address, discounts)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(
net=Money(expected_net, "USD"), gross=Money(expected_gross, "USD")
)
@pytest.mark.vcr
@pytest.mark.parametrize(
"with_discount, expected_net, expected_gross, voucher_amount, taxes_in_prices",
[
(True, "23.94", "28.98", "0.0", True),
(True, "23.98", "30.19", "5.0", False),
(False, "43.98", "53.64", "0.0", False),
(False, "33.13", "40.98", "3.0", True),
],
)
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_total(
with_discount,
expected_net,
expected_gross,
voucher_amount,
taxes_in_prices,
checkout_with_item,
product_with_single_variant,
discount_info,
shipping_zone,
address,
ship_to_pl_address,
site_settings,
monkeypatch,
plugin_configuration,
non_default_category,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PS081282": "desc"},
)
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.AvataxPlugin._skip_plugin", lambda *_: False
)
manager = get_plugins_manager()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.save()
site_settings.company_address = address
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
voucher_amount = Money(voucher_amount, "USD")
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.discount = voucher_amount
checkout_with_item.save()
line = checkout_with_item.lines.first()
product = line.variant.product
product.metadata = {}
manager.assign_tax_code_to_object_meta(product.product_type, "PS081282")
product.save()
product.product_type.save()
product_with_single_variant.charge_taxes = False
product_with_single_variant.category = non_default_category
product_with_single_variant.save()
discounts = [discount_info] if with_discount else None
checkout_info = fetch_checkout_info(checkout_with_item, [], discounts, manager)
add_variant_to_checkout(checkout_info, product_with_single_variant.variants.get())
lines = fetch_checkout_lines(checkout_with_item)
total = manager.calculate_checkout_total(
checkout_info, lines, ship_to_pl_address, discounts
)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(
net=Money(expected_net, "USD"), gross=Money(expected_gross, "USD")
)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_total_not_charged_product_and_shipping_with_0_price(
checkout_with_item,
shipping_zone,
address,
ship_to_pl_address,
site_settings,
monkeypatch,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PS081282": "desc"},
)
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.AvataxPlugin._skip_plugin", lambda *_: False
)
manager = get_plugins_manager()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.save()
site_settings.company_address = address
site_settings.include_taxes_in_prices = True
site_settings.save()
channel = checkout_with_item.channel
shipping_method = shipping_zone.shipping_methods.get()
shipping_channel_listing = shipping_method.channel_listings.get(channel=channel)
shipping_channel_listing.price = Money(0, "USD")
shipping_channel_listing.save()
checkout_with_item.shipping_method = shipping_method
checkout_with_item.save()
line = checkout_with_item.lines.first()
variant = line.variant
product = variant.product
product.charge_taxes = False
product.metadata = {}
manager.assign_tax_code_to_object_meta(product.product_type, "PS081282")
product.save()
product.product_type.save()
discounts = None
checkout_info = fetch_checkout_info(checkout_with_item, [], discounts, manager)
lines = fetch_checkout_lines(checkout_with_item)
total = manager.calculate_checkout_total(
checkout_info, lines, ship_to_pl_address, discounts
)
total = quantize_price(total, total.currency)
channel_listing = variant.channel_listings.get(channel=channel)
expected_amount = (line.quantity * channel_listing.price).amount
assert total == TaxedMoney(
net=Money(expected_amount, "USD"), gross=Money(expected_amount, "USD")
)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_shipping(
checkout_with_item,
shipping_zone,
discount_info,
address,
ship_to_pl_address,
site_settings,
monkeypatch,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(
checkout_with_item, lines, [discount_info], manager
)
shipping_price = manager.calculate_checkout_shipping(
checkout_info, lines, address, [discount_info]
)
shipping_price = quantize_price(shipping_price, shipping_price.currency)
assert shipping_price == TaxedMoney(
net=Money("8.13", "USD"), gross=Money("10.00", "USD")
)
@pytest.mark.vcr
@pytest.mark.parametrize(
"with_discount, expected_net, expected_gross, taxes_in_prices",
[
(True, "25.00", "30.75", False),
(False, "40.65", "50.00", True),
(False, "50.00", "61.50", False),
(True, "20.33", "25.00", True),
],
)
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_subtotal(
with_discount,
expected_net,
expected_gross,
taxes_in_prices,
discount_info,
checkout_with_item,
stock,
monkeypatch,
site_settings,
ship_to_pl_address,
shipping_zone,
address,
plugin_configuration,
):
plugin_configuration()
variant = stock.product_variant
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info] if with_discount else None
checkout_info = fetch_checkout_info(checkout_with_item, [], discounts, manager)
add_variant_to_checkout(checkout_info, variant, 2)
lines = fetch_checkout_lines(checkout_with_item)
total = manager.calculate_checkout_subtotal(
checkout_info, lines, address, discounts
)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(
net=Money(expected_net, "USD"), gross=Money(expected_gross, "USD")
)
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_subtotal_for_product_without_tax(
checkout,
stock,
monkeypatch,
site_settings,
ship_to_pl_address,
shipping_zone,
address,
plugin_configuration,
):
plugin_configuration()
variant = stock.product_variant
product = variant.product
product.charge_taxes = False
product.save(update_fields=["charge_taxes"])
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.include_taxes_in_prices = True
site_settings.save()
checkout.shipping_address = ship_to_pl_address
checkout.shipping_method = shipping_zone.shipping_methods.get()
checkout.save()
quantity = 2
checkout_info = fetch_checkout_info(checkout, [], [], manager)
add_variant_to_checkout(checkout_info, variant, quantity)
lines = fetch_checkout_lines(checkout)
assert len(lines) == 1
valid_methods = get_valid_shipping_method_list_for_checkout_info(
checkout_info, ship_to_pl_address, lines, [], manager
)
checkout_info.valid_shipping_methods = valid_methods
total = manager.calculate_checkout_subtotal(checkout_info, lines, address, [])
total = quantize_price(total, total.currency)
expected_total = variant.channel_listings.first().price_amount * quantity
assert total == TaxedMoney(
net=Money(expected_total, "USD"), gross=Money(expected_total, "USD")
)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_order_shipping(
order_line, shipping_zone, site_settings, address, plugin_configuration
):
plugin_configuration()
manager = get_plugins_manager()
order = order_line.order
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
site_settings.company_address = address
site_settings.save()
price = manager.calculate_order_shipping(order)
price = quantize_price(price, price.currency)
assert price == TaxedMoney(net=Money("8.13", "USD"), gross=Money("10.00", "USD"))
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_order_line_unit(
order_line,
shipping_zone,
site_settings,
address_usa,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager()
order_line.unit_price = TaxedMoney(
net=Money("10.00", "USD"), gross=Money("10.00", "USD")
)
order_line.save()
order = order_line.order
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
site_settings.company_address = address_usa
site_settings.save()
line_price = manager.calculate_order_line_unit(
order, order_line, order_line.variant, order_line.variant.product
)
line_price = quantize_price(line_price, line_price.currency)
assert line_price == TaxedMoney(
net=Money("8.13", "USD"), gross=Money("10.00", "USD")
)
@pytest.mark.vcr
@pytest.mark.parametrize("charge_taxes", [True, False])
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_calculate_checkout_line_unit_price(
charge_taxes,
checkout_with_item,
shipping_zone,
site_settings,
address_usa,
address,
plugin_configuration,
):
plugin_configuration()
checkout = checkout_with_item
total_price = TaxedMoney(
net=Money("10.00", "USD") * 3, gross=Money("10.00", "USD") * 3
)
lines = fetch_checkout_lines(checkout_with_item)
checkout_line = lines[0]
product = checkout_line.variant.product
product.charge_taxes = charge_taxes
product.save(update_fields=["charge_taxes"])
manager = get_plugins_manager()
method = shipping_zone.shipping_methods.get()
checkout.shipping_address = address
checkout.shipping_method_name = method.name
checkout.shipping_method = method
checkout.save()
site_settings.company_address = address_usa
site_settings.include_taxes_in_prices = True
site_settings.save()
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
line_price = manager.calculate_checkout_line_unit_price(
total_price,
checkout_line.line.quantity,
checkout_info,
lines,
checkout_line,
checkout.shipping_address,
[],
)
line_price = quantize_price(line_price, line_price.currency)
if charge_taxes:
assert line_price == TaxedMoney(
net=Money("8.13", "USD"), gross=Money("10.00", "USD")
)
else:
assert line_price == TaxedMoney(
net=Money("10.00", "USD"), gross=Money("10.00", "USD")
)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_preprocess_order_creation(
checkout_with_item,
monkeypatch,
address,
ship_to_pl_address,
site_settings,
shipping_zone,
discount_info,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, discounts, manager)
manager.preprocess_order_creation(checkout_info, discounts, lines)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_preprocess_order_creation_no_lines_data(
checkout_with_item,
monkeypatch,
address,
ship_to_pl_address,
site_settings,
shipping_zone,
discount_info,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, discounts, manager)
manager.preprocess_order_creation(checkout_info, discounts)
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_preprocess_order_creation_wrong_data(
checkout_with_item,
monkeypatch,
address,
shipping_zone,
discount_info,
plugin_configuration,
):
plugin_configuration("wrong", "wrong")
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, discounts, manager)
with pytest.raises(TaxError):
manager.preprocess_order_creation(checkout_info, discounts, lines)
@pytest.mark.vcr
def test_get_cached_tax_codes_or_fetch(monkeypatch):
monkeypatch.setattr("saleor.plugins.avatax.cache.get", lambda x, y: {})
config = AvataxConfiguration(
username_or_account="test",
password_or_license="test",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
tax_codes = get_cached_tax_codes_or_fetch(config)
assert len(tax_codes) > 0
@pytest.mark.vcr
def test_get_cached_tax_codes_or_fetch_wrong_response(monkeypatch):
monkeypatch.setattr("saleor.plugins.avatax.cache.get", lambda x, y: {})
config = AvataxConfiguration(
username_or_account="wrong_data",
password_or_license="wrong_data",
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
tax_codes = get_cached_tax_codes_or_fetch(config)
assert len(tax_codes) == 0
def test_checkout_needs_new_fetch(
monkeypatch, checkout_with_item, address, shipping_method
):
monkeypatch.setattr("saleor.plugins.avatax.cache.get", lambda x: None)
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_method
config = AvataxConfiguration(
username_or_account="wrong_data",
password_or_license="wrong_data",
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
manager = get_plugins_manager()
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
checkout_data = generate_request_data_from_checkout(checkout_info, lines, config)
assert taxes_need_new_fetch(checkout_data, str(checkout_with_item.token))
def test_taxes_need_new_fetch_uses_cached_data(
monkeypatch, checkout_with_item, address
):
checkout_with_item.shipping_address = address
config = AvataxConfiguration(
username_or_account="wrong_data",
password_or_license="wrong_data",
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
manager = get_plugins_manager()
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
checkout_data = generate_request_data_from_checkout(checkout_info, lines, config)
monkeypatch.setattr(
"saleor.plugins.avatax.cache.get", lambda x: [checkout_data, None]
)
assert not taxes_need_new_fetch(checkout_data, str(checkout_with_item.token))
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_line_tax_rate(
monkeypatch,
checkout_with_item,
address,
plugin_configuration,
shipping_zone,
site_settings,
):
# given
site_settings.company_address = address
site_settings.save()
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(14, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
checkout_info = CheckoutInfo(
checkout=checkout_with_item,
shipping_method=checkout_with_item.shipping_method,
shipping_address=address,
billing_address=None,
channel=checkout_with_item.channel,
user=None,
shipping_method_channel_listings=None,
valid_shipping_methods=[],
)
lines = fetch_checkout_lines(checkout_with_item)
checkout_line_info = lines[0]
# when
tax_rate = manager.get_checkout_line_tax_rate(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
[],
unit_price,
)
# then
assert tax_rate == Decimal("0.23")
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_line_tax_rate_for_product_with_charge_taxes_set_to_false(
monkeypatch,
checkout_with_item,
address,
plugin_configuration,
shipping_zone,
site_settings,
):
# given
site_settings.company_address = address
site_settings.save()
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(12, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
checkout_info = CheckoutInfo(
checkout=checkout_with_item,
shipping_method=checkout_with_item.shipping_method,
shipping_address=address,
billing_address=None,
channel=checkout_with_item.channel,
user=None,
shipping_method_channel_listings=None,
valid_shipping_methods=[],
)
lines = fetch_checkout_lines(checkout_with_item)
checkout_line_info = lines[0]
product = checkout_line_info.product
product.charge_taxes = False
product.save(update_fields=["charge_taxes"])
# when
tax_rate = manager.get_checkout_line_tax_rate(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
[],
unit_price,
)
# then
assert tax_rate == Decimal("0.0")
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_line_tax_rate_for_product_type_with_non_taxable_product(
monkeypatch,
checkout_with_item,
address,
plugin_configuration,
shipping_zone,
site_settings,
product_with_two_variants,
):
# given
site_settings.company_address = address
site_settings.save()
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"NT": "Non-Taxable Product"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(12, "USD"))
manager = get_plugins_manager()
product_type = ProductType.objects.create(name="non-taxable")
product2 = product_with_two_variants
product2.product_type = product_type
manager.assign_tax_code_to_object_meta(product_type, "NT")
product2.save()
product_type.save()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
variant2 = product2.variants.first()
checkout_info = CheckoutInfo(
checkout=checkout_with_item,
shipping_method=checkout_with_item.shipping_method,
shipping_address=address,
billing_address=None,
channel=checkout_with_item.channel,
user=None,
shipping_method_channel_listings=None,
valid_shipping_methods=[],
)
add_variant_to_checkout(checkout_info, variant2, 1)
assert checkout_with_item.lines.count() == 2
lines = fetch_checkout_lines(checkout_with_item)
order = [checkout_with_item.lines.first().variant.pk, variant2.pk]
lines.sort(key=lambda line: order.index(line.variant.pk))
# when
tax_rates = [
manager.get_checkout_line_tax_rate(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
[],
unit_price,
)
for checkout_line_info in lines
]
# then
assert tax_rates[0] == Decimal("0.23")
assert tax_rates[1] == Decimal("0.0")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_line_tax_rate_checkout_no_shipping_method_default_value_returned(
monkeypatch, checkout_with_item, address, plugin_configuration, site_settings
):
# given
site_settings.company_address = address
site_settings.save()
plugin_configuration()
unit_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.save(update_fields=["shipping_address"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
checkout_line_info = lines[0]
# when
tax_rate = manager.get_checkout_line_tax_rate(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
[],
unit_price,
)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_line_tax_rate_error_in_response(
monkeypatch, checkout_with_item, address, plugin_configuration, shipping_zone
):
# given
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_checkout_tax_data",
lambda *_: {"error": "Example error"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
checkout_line_info = lines[0]
# when
tax_rate = manager.get_checkout_line_tax_rate(
checkout_info,
lines,
checkout_line_info,
checkout_with_item.shipping_address,
[],
unit_price,
)
# then
assert tax_rate == Decimal("0.25")
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_line_tax_rate(
monkeypatch, order_line, shipping_zone, plugin_configuration, site_settings, address
):
# given
order = order_line.order
site_settings.company_address = address
site_settings.save()
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(14, "USD"))
manager = get_plugins_manager()
product = Product.objects.get(name=order_line.product_name)
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
# when
tax_rate = manager.get_order_line_tax_rate(
order,
product,
order_line.variant,
None,
unit_price,
)
# then
assert tax_rate == Decimal("0.23")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_line_tax_rate_order_not_valid_default_value_returned(
monkeypatch, order_line, shipping_zone, plugin_configuration
):
# given
order = order_line.order
plugin_configuration()
unit_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
product = Product.objects.get(name=order_line.product_name)
# when
tax_rate = manager.get_order_line_tax_rate(
order,
product,
order_line.variant,
None,
unit_price,
)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_line_tax_rate_error_in_response(
monkeypatch, order_line, shipping_zone, plugin_configuration
):
# given
order = order_line.order
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_order_tax_data",
lambda *_: {"error": "Example error"},
)
unit_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
product = Product.objects.get(name=order_line.product_name)
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
# when
tax_rate = manager.get_order_line_tax_rate(
order,
product,
order_line.variant,
None,
unit_price,
)
# then
assert tax_rate == Decimal("0.25")
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_shipping_tax_rate(
checkout_with_item, address, plugin_configuration, shipping_zone, site_settings
):
# given
site_settings.company_address = address
site_settings.save()
plugin_configuration()
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = CheckoutInfo(
checkout=checkout_with_item,
shipping_method=checkout_with_item.shipping_method,
shipping_address=address,
billing_address=None,
channel=checkout_with_item.channel,
user=None,
shipping_method_channel_listings=None,
valid_shipping_methods=[],
)
# when
tax_rate = manager.get_checkout_shipping_tax_rate(
checkout_info,
lines,
checkout_with_item.shipping_address,
[],
shipping_price,
)
# then
assert tax_rate == Decimal("0.23")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_shipping_tax_rate_checkout_not_valid_default_value_returned(
monkeypatch, checkout_with_item, address, plugin_configuration
):
# given
plugin_configuration()
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.save(update_fields=["shipping_address"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
# when
tax_rate = manager.get_checkout_shipping_tax_rate(
checkout_info,
lines,
checkout_with_item.shipping_address,
[],
shipping_price,
)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_shipping_tax_rate_error_in_response(
monkeypatch, checkout_with_item, address, plugin_configuration, shipping_zone
):
# given
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_checkout_tax_data",
lambda *_: {"error": "Example error"},
)
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
# when
tax_rate = manager.get_checkout_shipping_tax_rate(
checkout_info,
lines,
checkout_with_item.shipping_address,
[],
shipping_price,
)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_checkout_shipping_tax_rate_skip_plugin(
monkeypatch, checkout_with_item, address, plugin_configuration, shipping_zone
):
# given
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.AvataxPlugin._skip_plugin",
lambda *_: True,
)
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save(update_fields=["shipping_address", "shipping_method"])
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, [], manager)
# when
tax_rate = manager.get_checkout_shipping_tax_rate(
checkout_info,
lines,
checkout_with_item.shipping_address,
[],
shipping_price,
)
# then
assert tax_rate == Decimal("0.25")
@pytest.mark.vcr
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_shipping_tax_rate(
order_line, shipping_zone, plugin_configuration, site_settings, address
):
# given
site_settings.company_address = address
site_settings.save()
order = order_line.order
plugin_configuration()
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
# when
tax_rate = manager.get_order_shipping_tax_rate(order, shipping_price)
# then
assert tax_rate == Decimal("0.23")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_shipping_tax_rate_order_not_valid_default_value_returned(
order_line, shipping_zone, plugin_configuration
):
# given
order = order_line.order
plugin_configuration()
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
# when
tax_rate = manager.get_order_shipping_tax_rate(order, shipping_price)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_shipping_tax_rate_error_in_response(
monkeypatch, order_line, shipping_zone, plugin_configuration
):
# given
order = order_line.order
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_order_tax_data",
lambda *_: {"error": "Example error"},
)
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
# when
tax_rate = manager.get_order_shipping_tax_rate(order, shipping_price)
# then
assert tax_rate == Decimal("0.25")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_get_order_shipping_tax_rate_skip_plugin(
monkeypatch, order_line, shipping_zone, plugin_configuration
):
# given
order = order_line.order
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.AvataxPlugin._skip_plugin",
lambda *_: True,
)
shipping_price = TaxedMoney(Money(12, "USD"), Money(15, "USD"))
manager = get_plugins_manager()
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
# when
tax_rate = manager.get_order_shipping_tax_rate(order, shipping_price)
# then
assert tax_rate == Decimal("0.25")
def test_get_plugin_configuration(settings, channel_USD):
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
plugin = manager.get_plugin(AvataxPlugin.PLUGIN_ID)
configuration_fields = [
configuration_item["name"] for configuration_item in plugin.configuration
]
assert "Username or account" in configuration_fields
assert "Password or license" in configuration_fields
assert "Use sandbox" in configuration_fields
assert "Company name" in configuration_fields
assert "Autocommit" in configuration_fields
@patch("saleor.plugins.avatax.plugin.api_get_request")
def test_save_plugin_configuration(
api_get_request_mock, settings, channel_USD, plugin_configuration
):
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
plugin_configuration()
api_get_request_mock.return_value = {"authenticated": True}
manager = get_plugins_manager()
manager.save_plugin_configuration(
AvataxPlugin.PLUGIN_ID,
channel_USD.slug,
{
"active": True,
"configuration": [
{"name": "Username or account", "value": "test"},
{"name": "Password or license", "value": "test"},
],
},
)
manager.save_plugin_configuration(
AvataxPlugin.PLUGIN_ID, channel_USD.slug, {"active": True}
)
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxPlugin.PLUGIN_ID
)
assert plugin_configuration.active
@patch("saleor.plugins.avatax.plugin.api_get_request")
def test_save_plugin_configuration_authentication_failed(
api_get_request_mock, settings, channel_USD, plugin_configuration
):
# given
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
plugin_configuration(active=False)
api_get_request_mock.return_value = {"authenticated": False}
manager = get_plugins_manager()
# when
with pytest.raises(ValidationError) as e:
manager.save_plugin_configuration(
AvataxPlugin.PLUGIN_ID,
channel_USD.slug,
{
"active": True,
"configuration": [
{"name": "Username or account", "value": "test"},
{"name": "Password or license", "value": "test"},
],
},
)
# then
assert e._excinfo[1].args[0] == "Authentication failed. Please check provided data."
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxPlugin.PLUGIN_ID
)
assert not plugin_configuration.active
def test_save_plugin_configuration_cannot_be_enabled_without_config(
settings, plugin_configuration, channel_USD
):
plugin_configuration(None, None)
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
with pytest.raises(ValidationError):
manager.save_plugin_configuration(
AvataxPlugin.PLUGIN_ID, channel_USD.slug, {"active": True}
)
def test_show_taxes_on_storefront(plugin_configuration):
plugin_configuration()
manager = get_plugins_manager()
assert manager.show_taxes_on_storefront() is False
@patch("saleor.plugins.avatax.plugin.api_post_request_task.delay")
@override_settings(PLUGINS=["saleor.plugins.avatax.plugin.AvataxPlugin"])
def test_order_created(api_post_request_task_mock, order, plugin_configuration):
# given
plugin_conf = plugin_configuration(
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_postal_code="53-601",
from_country="PL",
)
conf = {data["name"]: data["value"] for data in plugin_conf.configuration}
manager = get_plugins_manager()
# when
manager.order_created(order)
# then
address = order.billing_address
expected_request_data = {
"createTransactionModel": {
"companyCode": conf["Company name"],
"type": TransactionType.INVOICE,
"lines": [],
"code": order.token,
"date": datetime.date.today().strftime("%Y-%m-%d"),
"customerCode": 0,
"addresses": {
"shipFrom": {
"line1": "Tęczowa 7",
"line2": None,
"city": "WROCŁAW",
"region": "",
"country": "PL",
"postalCode": "53-601",
},
"shipTo": {
"line1": address.street_address_1,
"line2": address.street_address_2,
"city": address.city,
"region": address.city_area or "",
"country": address.country.code,
"postalCode": address.postal_code,
},
},
"commit": False,
"currencyCode": order.currency,
"email": order.user_email,
}
}
conf_data = {
"username_or_account": conf["Username or account"],
"password_or_license": conf["Password or license"],
"use_sandbox": conf["Use sandbox"],
"company_name": conf["Company name"],
"autocommit": conf["Autocommit"],
"from_street_address": conf["from_street_address"],
"from_city": conf["from_city"],
"from_postal_code": conf["from_postal_code"],
"from_country": conf["from_country"],
"from_country_area": conf["from_country_area"],
}
api_post_request_task_mock.assert_called_once_with(
"https://rest.avatax.com/api/v2/transactions/createoradjust",
expected_request_data,
conf_data,
order.pk,
)
@pytest.mark.vcr
def test_plugin_uses_configuration_from_db(
plugin_configuration,
monkeypatch,
ship_to_pl_address,
site_settings,
address,
checkout_with_item,
shipping_zone,
discount_info,
settings,
):
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
configuration = plugin_configuration(
username="2000134479", password="697932CFCBDE505B", sandbox=False
)
manager = get_plugins_manager()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
site_settings.company_address = address
site_settings.save()
checkout_with_item.shipping_address = ship_to_pl_address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines, discounts, manager)
manager.preprocess_order_creation(checkout_info, discounts, lines)
field_to_update = [
{"name": "Username or account", "value": "New value"},
{"name": "Password or license", "value": "Wrong pass"},
]
AvataxPlugin._update_config_items(field_to_update, configuration.configuration)
configuration.save()
manager = get_plugins_manager()
with pytest.raises(TaxError):
manager.preprocess_order_creation(checkout_info, discounts, lines)
def test_skip_disabled_plugin(settings, plugin_configuration):
plugin_configuration(username=None, password=None)
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
plugin: AvataxPlugin = manager.get_plugin(AvataxPlugin.PLUGIN_ID)
assert (
plugin._skip_plugin(
previous_value=TaxedMoney(net=Money(0, "USD"), gross=Money(0, "USD"))
)
is True
)
def test_get_tax_code_from_object_meta(product, settings, plugin_configuration):
product.store_value_in_metadata(
{META_CODE_KEY: "KEY", META_DESCRIPTION_KEY: "DESC"}
)
plugin_configuration(username=None, password=None)
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
tax_type = manager.get_tax_code_from_object_meta(product)
assert isinstance(tax_type, TaxType)
assert tax_type.code == "KEY"
assert tax_type.description == "DESC"
def test_api_get_request_handles_request_errors(product, monkeypatch):
mocked_response = Mock(side_effect=RequestException())
monkeypatch.setattr("saleor.plugins.avatax.requests.get", mocked_response)
config = AvataxConfiguration(
username_or_account="test",
password_or_license="test",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
url = "https://www.avatax.api.com/some-get-path"
response = api_get_request(
url, config.username_or_account, config.password_or_license
)
assert response == {}
assert mocked_response.called
def test_api_get_request_handles_json_errors(product, monkeypatch):
mocked_response = Mock(side_effect=JSONDecodeError("", "", 0))
monkeypatch.setattr("saleor.plugins.avatax.requests.get", mocked_response)
config = AvataxConfiguration(
username_or_account="test",
password_or_license="test",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
url = "https://www.avatax.api.com/some-get-path"
response = api_get_request(
url, config.username_or_account, config.password_or_license
)
assert response == {}
assert mocked_response.called
def test_api_post_request_handles_request_errors(product, monkeypatch):
mocked_response = Mock(side_effect=RequestException())
monkeypatch.setattr("saleor.plugins.avatax.requests.post", mocked_response)
config = AvataxConfiguration(
username_or_account="test",
password_or_license="test",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
url = "https://www.avatax.api.com/some-get-path"
response = api_post_request(url, {}, config)
assert mocked_response.called
assert response == {}
def test_api_post_request_handles_json_errors(product, monkeypatch):
mocked_response = Mock(side_effect=JSONDecodeError("", "", 0))
monkeypatch.setattr("saleor.plugins.avatax.requests.post", mocked_response)
config = AvataxConfiguration(
username_or_account="test",
password_or_license="test",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
url = "https://www.avatax.api.com/some-get-path"
response = api_post_request(url, {}, config)
assert mocked_response.called
assert response == {}
def test_get_order_request_data_checks_when_taxes_are_included_to_price(
order_with_lines, shipping_zone, site_settings, address
):
site_settings.include_taxes_in_prices = True
site_settings.company_address = address
site_settings.save()
method = shipping_zone.shipping_methods.get()
line = order_with_lines.lines.first()
line.unit_price_gross_amount = line.unit_price_net_amount
line.save()
order_with_lines.shipping_address = order_with_lines.billing_address.get_copy()
order_with_lines.shipping_method_name = method.name
order_with_lines.shipping_method = method
order_with_lines.save()
config = AvataxConfiguration(
username_or_account="",
password_or_license="",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
request_data = get_order_request_data(order_with_lines, config)
lines_data = request_data["createTransactionModel"]["lines"]
assert all([line for line in lines_data if line["taxIncluded"] is True])
def test_get_order_request_data_checks_when_taxes_are_not_included_to_price(
order_with_lines, shipping_zone, site_settings, address_usa
):
site_settings.company_address = address_usa
site_settings.include_taxes_in_prices = False
site_settings.save()
method = shipping_zone.shipping_methods.get()
line = order_with_lines.lines.first()
line.unit_price_gross_amount = line.unit_price_net_amount
line.save()
order_with_lines.shipping_address = order_with_lines.billing_address.get_copy()
order_with_lines.shipping_method_name = method.name
order_with_lines.shipping_method = method
order_with_lines.save()
config = AvataxConfiguration(
username_or_account="",
password_or_license="",
use_sandbox=False,
from_street_address="Tęczowa 7",
from_city="WROCŁAW",
from_country_area="",
from_postal_code="53-601",
from_country="PL",
)
request_data = get_order_request_data(order_with_lines, config)
lines_data = request_data["createTransactionModel"]["lines"]
line_without_taxes = [line for line in lines_data if line["taxIncluded"] is False]
# if order line has different .net and .gross we already added tax to it
lines_with_taxes = [line for line in lines_data if line["taxIncluded"] is True]
assert len(line_without_taxes) == 2
assert len(lines_with_taxes) == 1
assert line_without_taxes[0]["itemCode"] == line.product_sku
@patch("saleor.plugins.avatax.get_order_request_data")
@patch("saleor.plugins.avatax.get_cached_response_or_fetch")
def test_get_order_tax_data(
get_cached_response_or_fetch_mock,
get_order_request_data_mock,
order,
plugin_configuration,
):
# given
conf = plugin_configuration()
return_value = {"id": 0, "code": "3d4893da", "companyId": 123}
get_cached_response_or_fetch_mock.return_value = return_value
# when
response = get_order_tax_data(order, conf)
# then
get_order_request_data_mock.assert_called_once_with(order, conf)
assert response == return_value
@patch("saleor.plugins.avatax.get_order_request_data")
@patch("saleor.plugins.avatax.get_cached_response_or_fetch")
def test_get_order_tax_data_raised_error(
get_cached_response_or_fetch_mock,
get_order_request_data_mock,
order,
plugin_configuration,
):
# given
conf = plugin_configuration()
return_value = {"error": {"message": "test error"}}
get_cached_response_or_fetch_mock.return_value = return_value
# when
with pytest.raises(TaxError) as e:
get_order_tax_data(order, conf)
# then
assert e._excinfo[1].args[0] == return_value["error"]
@pytest.mark.parametrize(
"shipping_address_none, shipping_method_none, billing_address_none, "
"is_shipping_required, expected_is_valid",
[
(False, False, False, True, True),
(True, True, False, True, False),
(True, True, False, False, True),
(False, True, False, True, False),
(True, False, False, True, False),
],
)
def test_validate_adddress_details(
shipping_address_none,
shipping_method_none,
billing_address_none,
is_shipping_required,
expected_is_valid,
checkout_ready_to_complete,
):
shipping_address = checkout_ready_to_complete.shipping_address
shipping_address = None if shipping_address_none else shipping_address
billing_address = checkout_ready_to_complete.billing_address
billing_address = None if billing_address_none else billing_address
address = shipping_address or billing_address
shipping_method = checkout_ready_to_complete.shipping_method
shipping_method = None if shipping_method_none else shipping_method
is_valid = _validate_adddress_details(
shipping_address, is_shipping_required, address, shipping_method
)
assert is_valid is expected_is_valid
|
"""
This file offers the methods to automatically retrieve the graph Nocardia higoensis.
The graph is automatically retrieved from the STRING repository.
References
---------------------
Please cite the following if you use the data:
```bib
@article{szklarczyk2019string,
title={STRING v11: protein--protein association networks with increased coverage, supporting functional discovery in genome-wide experimental datasets},
author={Szklarczyk, Damian and Gable, Annika L and Lyon, David and Junge, Alexander and Wyder, Stefan and Huerta-Cepas, Jaime and Simonovic, Milan and Doncheva, Nadezhda T and Morris, John H and Bork, Peer and others},
journal={Nucleic acids research},
volume={47},
number={D1},
pages={D607--D613},
year={2019},
publisher={Oxford University Press}
}
```
"""
from typing import Dict
from ..automatic_graph_retrieval import AutomaticallyRetrievedGraph
from ...ensmallen import Graph # pylint: disable=import-error
def NocardiaHigoensis(
directed: bool = False,
preprocess: bool = True,
load_nodes: bool = True,
verbose: int = 2,
cache: bool = True,
cache_path: str = "graphs/string",
version: str = "links.v11.5",
**additional_graph_kwargs: Dict
) -> Graph:
"""Return new instance of the Nocardia higoensis graph.
The graph is automatically retrieved from the STRING repository.
Parameters
-------------------
directed: bool = False
Wether to load the graph as directed or undirected.
By default false.
preprocess: bool = True
Whether to preprocess the graph to be loaded in
optimal time and memory.
load_nodes: bool = True,
Whether to load the nodes vocabulary or treat the nodes
simply as a numeric range.
verbose: int = 2,
Wether to show loading bars during the retrieval and building
of the graph.
cache: bool = True
Whether to use cache, i.e. download files only once
and preprocess them only once.
cache_path: str = "graphs"
Where to store the downloaded graphs.
version: str = "links.v11.5"
The version of the graph to retrieve.
The available versions are:
- homology.v11.0
- homology.v11.5
- physical.links.v11.0
- physical.links.v11.5
- links.v11.0
- links.v11.5
additional_graph_kwargs: Dict
Additional graph kwargs.
Returns
-----------------------
Instace of Nocardia higoensis graph.
References
---------------------
Please cite the following if you use the data:
```bib
@article{szklarczyk2019string,
title={STRING v11: protein--protein association networks with increased coverage, supporting functional discovery in genome-wide experimental datasets},
author={Szklarczyk, Damian and Gable, Annika L and Lyon, David and Junge, Alexander and Wyder, Stefan and Huerta-Cepas, Jaime and Simonovic, Milan and Doncheva, Nadezhda T and Morris, John H and Bork, Peer and others},
journal={Nucleic acids research},
volume={47},
number={D1},
pages={D607--D613},
year={2019},
publisher={Oxford University Press}
}
```
"""
return AutomaticallyRetrievedGraph(
graph_name="NocardiaHigoensis",
repository="string",
version=version,
directed=directed,
preprocess=preprocess,
load_nodes=load_nodes,
verbose=verbose,
cache=cache,
cache_path=cache_path,
additional_graph_kwargs=additional_graph_kwargs
)()
|
import React, { Component } from 'react';
import { Link, withRouter } from 'react-router-dom';
import { withFirebase } from '../../components/Firebase';
import { Input, Button } from '../../components';
import * as ROUTES from '../../constants/routes';
const PasswordForgetPage = () => (
<div>
<h1>PasswordForget</h1>
<PasswordForgetForm />
</div>
);
const INITIAL_STATE = {
email: '',
error: null,
hasReset: false,
}
class PasswordForgetFormBase extends Component {
constructor(props) {
super(props)
this.state = { ...INITIAL_STATE }
}
onSubmit = event => {
const { email } = this.state
this.props.firebase
.doPasswordReset(email)
.then(() => {
this.setState({ email: '', error: null, hasReset: true })
})
.catch(error => {
this.setState({ error })
})
event.preventDefault()
}
onChange = event => {
this.setState({ [event.target.name]: event.target.value })
}
render() {
console.log('AT | psfnobd:', this.props);
const { email, error, hasReset } = this.state;
const isInvalid = email === '';
return (
<React.Fragment>
<form onSubmit={this.onSubmit} style={{ display: 'flex', justifyContent: 'center', flexDirection: 'column', alignItems: 'center' }}>
<Input
name='email'
value={this.state.email}
handleChange={this.onChange}
type='text'
placeholder='Email Address'
/>
<Button text="Submit" disabled={isInvalid} type='submit' medium />
{error && <p className="orange padding-on fadeIn">{error.message}</p>}
{hasReset && <p className="orange padding-on fadeIn">Please check your email for your reset instructions!</p>}
</form>
{hasReset && (
<div style={{ display: 'flex', justifyContent: 'center', flexDirection: 'column', alignItems: 'center' }}>
<Button onClick={() => this.props.history.push('/signin')} text="Go back to Sign In?" medium />
</div>
)}
</React.Fragment>
)
}
}
export default PasswordForgetPage;
const PasswordForgetForm = withRouter(withFirebase(PasswordForgetFormBase));
export {
PasswordForgetForm,
}
|
"""
Training Transformer models using Pipeline Parallelism
======================================================
**Author**: `Pritam Damania <https://github.com/pritamdamania87>`_
This tutorial demonstrates how to train a large Transformer model across
multiple GPUs using pipeline parallelism. This tutorial is an extension of the
`Sequence-to-Sequence Modeling with nn.Transformer and TorchText <https://pytorch.org/tutorials/beginner/transformer_tutorial.html>`__ tutorial
and scales up the same model to demonstrate how pipeline parallelism can be
used to train Transformer models.
Prerequisites:
* `Pipeline Parallelism <https://pytorch.org/docs/stable/pipeline.html>`__
* `Sequence-to-Sequence Modeling with nn.Transformer and TorchText <https://pytorch.org/tutorials/beginner/transformer_tutorial.html>`__
"""
######################################################################
# Define the model
# ----------------
#
######################################################################
# In this tutorial, we will split a Transformer model across two GPUs and use
# pipeline parallelism to train the model. The model is exactly the same model
# used in the `Sequence-to-Sequence Modeling with nn.Transformer and TorchText
# <https://pytorch.org/tutorials/beginner/transformer_tutorial.html>`__ tutorial,
# but is split into two stages. The largest number of parameters belong to the
# `nn.TransformerEncoder <https://pytorch.org/docs/stable/generated/torch.nn.TransformerEncoder.html>`__ layer.
# The `nn.TransformerEncoder <https://pytorch.org/docs/stable/generated/torch.nn.TransformerEncoder.html>`__
# itself consists of ``nlayers`` of `nn.TransformerEncoderLayer <https://pytorch.org/docs/stable/generated/torch.nn.TransformerEncoderLayer.html>`__.
# As a result, our focus is on ``nn.TransformerEncoder`` and we split the model
# such that half of the ``nn.TransformerEncoderLayer`` are on one GPU and the
# other half are on another. To do this, we pull out the ``Encoder`` and
# ``Decoder`` sections into seperate modules and then build an nn.Sequential
# representing the original Transformer module.
import sys
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import tempfile
from torch.nn import TransformerEncoder, TransformerEncoderLayer
if sys.platform == 'win32':
print('Windows platform is not supported for pipeline parallelism')
sys.exit(0)
if torch.cuda.device_count() < 2:
print('Need at least two GPU devices for this tutorial')
sys.exit(0)
class Encoder(nn.Module):
def __init__(self, ntoken, ninp, dropout=0.5):
super(Encoder, self).__init__()
self.pos_encoder = PositionalEncoding(ninp, dropout)
self.encoder = nn.Embedding(ntoken, ninp)
self.ninp = ninp
self.init_weights()
def init_weights(self):
initrange = 0.1
self.encoder.weight.data.uniform_(-initrange, initrange)
def forward(self, src):
# Need (S, N) format for encoder.
src = src.t()
src = self.encoder(src) * math.sqrt(self.ninp)
return self.pos_encoder(src)
class Decoder(nn.Module):
def __init__(self, ntoken, ninp):
super(Decoder, self).__init__()
self.decoder = nn.Linear(ninp, ntoken)
self.init_weights()
def init_weights(self):
initrange = 0.1
self.decoder.bias.data.zero_()
self.decoder.weight.data.uniform_(-initrange, initrange)
def forward(self, inp):
# Need batch dimension first for output of pipeline.
return self.decoder(inp).permute(1, 0, 2)
######################################################################
# ``PositionalEncoding`` module injects some information about the
# relative or absolute position of the tokens in the sequence. The
# positional encodings have the same dimension as the embeddings so that
# the two can be summed. Here, we use ``sine`` and ``cosine`` functions of
# different frequencies.
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0).transpose(0, 1)
self.register_buffer('pe', pe)
def forward(self, x):
x = x + self.pe[:x.size(0), :]
return self.dropout(x)
######################################################################
# Load and batch data
# -------------------
#
######################################################################
# The training process uses Wikitext-2 dataset from ``torchtext``. The
# vocab object is built based on the train dataset and is used to numericalize
# tokens into tensors. Starting from sequential data, the ``batchify()``
# function arranges the dataset into columns, trimming off any tokens remaining
# after the data has been divided into batches of size ``batch_size``.
# For instance, with the alphabet as the sequence (total length of 26)
# and a batch size of 4, we would divide the alphabet into 4 sequences of
# length 6:
#
# .. math::
# \begin{bmatrix}
# \text{A} & \text{B} & \text{C} & \ldots & \text{X} & \text{Y} & \text{Z}
# \end{bmatrix}
# \Rightarrow
# \begin{bmatrix}
# \begin{bmatrix}\text{A} \\ \text{B} \\ \text{C} \\ \text{D} \\ \text{E} \\ \text{F}\end{bmatrix} &
# \begin{bmatrix}\text{G} \\ \text{H} \\ \text{I} \\ \text{J} \\ \text{K} \\ \text{L}\end{bmatrix} &
# \begin{bmatrix}\text{M} \\ \text{N} \\ \text{O} \\ \text{P} \\ \text{Q} \\ \text{R}\end{bmatrix} &
# \begin{bmatrix}\text{S} \\ \text{T} \\ \text{U} \\ \text{V} \\ \text{W} \\ \text{X}\end{bmatrix}
# \end{bmatrix}
#
# These columns are treated as independent by the model, which means that
# the dependence of ``G`` and ``F`` can not be learned, but allows more
# efficient batch processing.
#
import torch
from torchtext.datasets import WikiText2
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
train_iter = WikiText2(split='train')
tokenizer = get_tokenizer('basic_english')
vocab = build_vocab_from_iterator(map(tokenizer, train_iter), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"])
def data_process(raw_text_iter):
data = [torch.tensor(vocab(tokenizer(item)), dtype=torch.long) for item in raw_text_iter]
return torch.cat(tuple(filter(lambda t: t.numel() > 0, data)))
train_iter, val_iter, test_iter = WikiText2()
train_data = data_process(train_iter)
val_data = data_process(val_iter)
test_data = data_process(test_iter)
device = torch.device("cuda")
def batchify(data, bsz):
# Divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).t().contiguous()
return data.to(device)
batch_size = 20
eval_batch_size = 10
train_data = batchify(train_data, batch_size)
val_data = batchify(val_data, eval_batch_size)
test_data = batchify(test_data, eval_batch_size)
######################################################################
# Functions to generate input and target sequence
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
######################################################################
# ``get_batch()`` function generates the input and target sequence for
# the transformer model. It subdivides the source data into chunks of
# length ``bptt``. For the language modeling task, the model needs the
# following words as ``Target``. For example, with a ``bptt`` value of 2,
# we'd get the following two Variables for ``i`` = 0:
#
# .. image:: ../_static/img/transformer_input_target.png
#
# It should be noted that the chunks are along dimension 0, consistent
# with the ``S`` dimension in the Transformer model. The batch dimension
# ``N`` is along dimension 1.
#
bptt = 35
def get_batch(source, i):
seq_len = min(bptt, len(source) - 1 - i)
data = source[i:i+seq_len]
target = source[i+1:i+1+seq_len].view(-1)
# Need batch dimension first for pipeline parallelism.
return data.t(), target
######################################################################
# Model scale and Pipe initialization
# -----------------------------------
#
######################################################################
# To demonstrate training large Transformer models using pipeline parallelism,
# we scale up the Transformer layers appropriately. We use an embedding
# dimension of 4096, hidden size of 4096, 16 attention heads and 12 total
# transformer layers (``nn.TransformerEncoderLayer``). This creates a model with
# **~1.4 billion** parameters.
#
# We need to initialize the `RPC Framework <https://pytorch.org/docs/stable/rpc.html>`__
# since Pipe depends on the RPC framework via `RRef <https://pytorch.org/docs/stable/rpc.html#rref>`__
# which allows for future expansion to cross host pipelining. We need to
# initialize the RPC framework with only a single worker since we're using a
# single process to drive multiple GPUs.
#
# The pipeline is then initialized with 8 transformer layers on one GPU and 8
# transformer layers on the other GPU.
#
# .. note::
# For efficiency purposes we ensure that the ``nn.Sequential`` passed to
# ``Pipe`` only consists of two elements (corresponding to two GPUs), this
# allows the Pipe to work with only two partitions and avoid any
# cross-partition overheads.
ntokens = len(vocab) # the size of vocabulary
emsize = 4096 # embedding dimension
nhid = 4096 # the dimension of the feedforward network model in nn.TransformerEncoder
nlayers = 12 # the number of nn.TransformerEncoderLayer in nn.TransformerEncoder
nhead = 16 # the number of heads in the multiheadattention models
dropout = 0.2 # the dropout value
from torch.distributed import rpc
tmpfile = tempfile.NamedTemporaryFile()
rpc.init_rpc(
name="worker",
rank=0,
world_size=1,
rpc_backend_options=rpc.TensorPipeRpcBackendOptions(
init_method="file://{}".format(tmpfile.name),
# Specifying _transports and _channels is a workaround and we no longer
# will have to specify _transports and _channels for PyTorch
# versions >= 1.8.1
_transports=["ibv", "uv"],
_channels=["cuda_ipc", "cuda_basic"],
)
)
num_gpus = 2
partition_len = ((nlayers - 1) // num_gpus) + 1
# Add encoder in the beginning.
tmp_list = [Encoder(ntokens, emsize, dropout).cuda(0)]
module_list = []
# Add all the necessary transformer blocks.
for i in range(nlayers):
transformer_block = TransformerEncoderLayer(emsize, nhead, nhid, dropout)
if i != 0 and i % (partition_len) == 0:
module_list.append(nn.Sequential(*tmp_list))
tmp_list = []
device = i // (partition_len)
tmp_list.append(transformer_block.to(device))
# Add decoder in the end.
tmp_list.append(Decoder(ntokens, emsize).cuda(num_gpus - 1))
module_list.append(nn.Sequential(*tmp_list))
from torch.distributed.pipeline.sync import Pipe
# Build the pipeline.
chunks = 8
model = Pipe(torch.nn.Sequential(*module_list), chunks = chunks)
def get_total_params(module: torch.nn.Module):
total_params = 0
for param in module.parameters():
total_params += param.numel()
return total_params
print ('Total parameters in model: {:,}'.format(get_total_params(model)))
######################################################################
# Run the model
# -------------
#
######################################################################
# `CrossEntropyLoss <https://pytorch.org/docs/master/nn.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss>`__
# is applied to track the loss and
# `SGD <https://pytorch.org/docs/master/optim.html?highlight=sgd#torch.optim.SGD>`__
# implements stochastic gradient descent method as the optimizer. The initial
# learning rate is set to 5.0. `StepLR <https://pytorch.org/docs/master/optim.html?highlight=steplr#torch.optim.lr_scheduler.StepLR>`__ is
# applied to adjust the learn rate through epochs. During the
# training, we use
# `nn.utils.clip_grad_norm\_ <https://pytorch.org/docs/master/nn.html?highlight=nn%20utils%20clip_grad_norm#torch.nn.utils.clip_grad_norm_>`__
# function to scale all the gradient together to prevent exploding.
#
criterion = nn.CrossEntropyLoss()
lr = 5.0 # learning rate
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.95)
import time
def train():
model.train() # Turn on the train mode
total_loss = 0.
start_time = time.time()
ntokens = len(vocab)
# Train only for 50 batches to keep script execution time low.
nbatches = min(50 * bptt, train_data.size(0) - 1)
for batch, i in enumerate(range(0, nbatches, bptt)):
data, targets = get_batch(train_data, i)
optimizer.zero_grad()
# Since the Pipe is only within a single host and process the ``RRef``
# returned by forward method is local to this node and can simply
# retrieved via ``RRef.local_value()``.
output = model(data).local_value()
# Need to move targets to the device where the output of the
# pipeline resides.
loss = criterion(output.view(-1, ntokens), targets.cuda(1))
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
total_loss += loss.item()
log_interval = 10
if batch % log_interval == 0 and batch > 0:
cur_loss = total_loss / log_interval
elapsed = time.time() - start_time
print('| epoch {:3d} | {:5d}/{:5d} batches | '
'lr {:02.2f} | ms/batch {:5.2f} | '
'loss {:5.2f} | ppl {:8.2f}'.format(
epoch, batch, nbatches // bptt, scheduler.get_lr()[0],
elapsed * 1000 / log_interval,
cur_loss, math.exp(cur_loss)))
total_loss = 0
start_time = time.time()
def evaluate(eval_model, data_source):
eval_model.eval() # Turn on the evaluation mode
total_loss = 0.
ntokens = len(vocab)
# Evaluate only for 50 batches to keep script execution time low.
nbatches = min(50 * bptt, data_source.size(0) - 1)
with torch.no_grad():
for i in range(0, nbatches, bptt):
data, targets = get_batch(data_source, i)
output = eval_model(data).local_value()
output_flat = output.view(-1, ntokens)
# Need to move targets to the device where the output of the
# pipeline resides.
total_loss += len(data) * criterion(output_flat, targets.cuda(1)).item()
return total_loss / (len(data_source) - 1)
######################################################################
# Loop over epochs. Save the model if the validation loss is the best
# we've seen so far. Adjust the learning rate after each epoch.
best_val_loss = float("inf")
epochs = 3 # The number of epochs
best_model = None
for epoch in range(1, epochs + 1):
epoch_start_time = time.time()
train()
val_loss = evaluate(model, val_data)
print('-' * 89)
print('| end of epoch {:3d} | time: {:5.2f}s | valid loss {:5.2f} | '
'valid ppl {:8.2f}'.format(epoch, (time.time() - epoch_start_time),
val_loss, math.exp(val_loss)))
print('-' * 89)
if val_loss < best_val_loss:
best_val_loss = val_loss
best_model = model
scheduler.step()
######################################################################
# Evaluate the model with the test dataset
# -------------------------------------
#
######################################################################
# Apply the best model to check the result with the test dataset.
test_loss = evaluate(best_model, test_data)
print('=' * 89)
print('| End of training | test loss {:5.2f} | test ppl {:8.2f}'.format(
test_loss, math.exp(test_loss)))
print('=' * 89)
|
# coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. 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.
""" Configuration base class and utilities."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import json
import unicodedata
from functools import lru_cache
# import re
import regex as re
import six
from six.moves import range
def load_vocab(vocab_file):
"""Loads a vocabulary file into a dictionary."""
vocab = collections.OrderedDict()
fin = open(vocab_file)
for num, line in enumerate(fin):
items = convert_to_unicode(line.strip()).split("\t")
if len(items) > 2:
break
token = items[0]
index = items[1] if len(items) == 2 else num
token = token.strip()
vocab[token] = int(index)
return vocab
def convert_to_unicode(text):
"""Converts `text` to Unicode (if it's not already), assuming utf-8 input."""
if six.PY3:
if isinstance(text, str):
return text
elif isinstance(text, bytes):
return six.ensure_text(text, "utf-8", "ignore")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
elif six.PY2:
if isinstance(text, str):
return six.ensure_text(text, "utf-8", "ignore")
elif isinstance(text, six.text_type):
return text
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
else:
raise ValueError("Not running on Python2 or Python 3?")
def printable_text(text):
"""Returns text encoded in a way suitable for print or `tf.logging`."""
# These functions want `str` for both Python2 and Python3, but in one case
# it's a Unicode string and in the other it's a byte string.
if six.PY3:
if isinstance(text, str):
return text
elif isinstance(text, bytes):
return six.ensure_text(text, "utf-8", "ignore")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
elif six.PY2:
if isinstance(text, str):
return text
elif isinstance(text, six.text_type):
return six.ensure_binary(text, "utf-8")
else:
raise ValueError("Unsupported string type: %s" % (type(text)))
else:
raise ValueError("Not running on Python2 or Python 3?")
def convert_by_vocab(vocab, items):
"""Converts a sequence of [tokens|ids] using the vocab."""
output = []
for item in items:
output.append(vocab[item])
return output
def convert_tokens_to_ids(vocab, tokens):
"""get ids of tokens"""
return convert_by_vocab(vocab, tokens)
def convert_ids_to_tokens(inv_vocab, ids):
"""get tokens of ids"""
return convert_by_vocab(inv_vocab, ids)
def whitespace_tokenize(text):
"""Runs basic whitespace cleaning and splitting on a piece of text."""
text = text.strip()
if not text:
return []
tokens = text.split()
return tokens
def _is_whitespace(char):
"""Checks whether `chars` is a whitespace character."""
# \t, \n, and \r are technically control characters but we treat them
# as whitespace since they are generally considered as such.
if char == " " or char == "\t" or char == "\n" or char == "\r":
return True
cat = unicodedata.category(char)
if cat == "Zs":
return True
return False
def _is_control(char):
"""Checks whether `chars` is a control character."""
# These are technically control characters but we count them as whitespace
# characters.
if char == "\t" or char == "\n" or char == "\r":
return False
cat = unicodedata.category(char)
if cat in ("Cc", "Cf"):
return True
return False
def _is_punctuation(char):
"""Checks whether `chars` is a punctuation character."""
cp = ord(char)
# We treat all non-letter/number ASCII as punctuation.
# Characters such as "^", "$", and "`" are not in the Unicode
# Punctuation class but we treat them as punctuation anyways, for
# consistency.
if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or
(cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)):
return True
cat = unicodedata.category(char)
if cat.startswith("P"):
return True
return False
class PreTrainedFullTokenizer(object):
"""base FullTokenizer class"""
def __init__(self, vocab_file, do_lower_case=True):
"""Constructs a PreTrainedFullTokenizer. """
self.vocab = None
self.inv_vocab = None
def tokenize(self, text):
""" tokenize interface"""
raise NotImplementedError
def convert_tokens_to_ids(self, tokens):
""" convert_tokens_to_ids interface"""
raise NotImplementedError
def convert_ids_to_tokens(self, ids):
""" convert_ids_to_tokens interface"""
raise NotImplementedError
class PreTrainedBasicTokenizer(object):
"""base BasicTokenizer class """
def __init__(self, do_lower_case=True):
"""Constructs a BasicTokenizer.
Args:
do_lower_case: Whether to lower case the input.
"""
self.do_lower_case = do_lower_case
def tokenize(self, text):
"""Tokenizes a piece of text."""
text = convert_to_unicode(text)
text = self._clean_text(text)
# This was added on November 1st, 2018 for the multilingual and Chinese
# models. This is also applied to the English models now, but it doesn't
# matter since the English models were not trained on any Chinese data
# and generally don't have any Chinese data in them (there are Chinese
# characters in the vocabulary because Wikipedia does have some Chinese
# words in the English Wikipedia.).
text = self._tokenize_chinese_chars(text)
orig_tokens = whitespace_tokenize(text)
split_tokens = []
for token in orig_tokens:
if self.do_lower_case:
token = token.lower()
token = self._run_strip_accents(token)
split_tokens.extend(self._run_split_on_punc(token))
output_tokens = whitespace_tokenize(" ".join(split_tokens))
return output_tokens
def _run_strip_accents(self, text):
"""Strips accents from a piece of text."""
text = unicodedata.normalize("NFD", text)
output = []
for char in text:
cat = unicodedata.category(char)
if cat == "Mn":
continue
output.append(char)
return "".join(output)
def _run_split_on_punc(self, text):
"""Splits punctuation on a piece of text."""
chars = list(text)
i = 0
start_new_word = True
output = []
while i < len(chars):
char = chars[i]
if _is_punctuation(char):
output.append([char])
start_new_word = True
else:
if start_new_word:
output.append([])
start_new_word = False
output[-1].append(char)
i += 1
return ["".join(x) for x in output]
def _tokenize_chinese_chars(self, text):
"""Adds whitespace around any CJK character."""
output = []
for char in text:
cp = ord(char)
if self._is_chinese_char(cp):
output.append(" ")
output.append(char)
output.append(" ")
else:
output.append(char)
return "".join(output)
def _is_chinese_char(self, cp):
"""Checks whether CP is the codepoint of a CJK character."""
# This defines a "chinese character" as anything in the CJK Unicode block:
# https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
#
# Note that the CJK Unicode block is NOT all Japanese and Korean characters,
# despite its name. The modern Korean Hangul alphabet is a different block,
# as is Japanese Hiragana and Katakana. Those alphabets are used to write
# space-separated words, so they are not treated specially and handled
# like the all of the other languages.
if ((cp >= 0x4E00 and cp <= 0x9FFF) or #
(cp >= 0x3400 and cp <= 0x4DBF) or #
(cp >= 0x20000 and cp <= 0x2A6DF) or #
(cp >= 0x2A700 and cp <= 0x2B73F) or #
(cp >= 0x2B740 and cp <= 0x2B81F) or #
(cp >= 0x2B820 and cp <= 0x2CEAF) or
(cp >= 0xF900 and cp <= 0xFAFF) or #
(cp >= 0x2F800 and cp <= 0x2FA1F)): #
return True
return False
def _clean_text(self, text):
"""Performs invalid character removal and whitespace cleanup on text."""
output = []
for char in text:
cp = ord(char)
if cp == 0 or cp == 0xfffd or _is_control(char):
continue
if _is_whitespace(char):
output.append(" ")
else:
output.append(char)
return "".join(output)
class PreTrainedWordpieceTokenizer(object):
"""Runs WordPiece tokenziation."""
def __init__(self, vocab, unk_token="<unk>", max_input_chars_per_word=200):
self.vocab = vocab
self.unk_token = unk_token
self.max_input_chars_per_word = max_input_chars_per_word
def tokenize(self, text):
"""Tokenizes a piece of text into its word pieces.
This uses a greedy longest-match-first algorithm to perform tokenization
using the given vocabulary.
For example:
input = "unaffable"
output = ["un", "##aff", "##able"]
Args:
text: A single token or whitespace separated tokens. This should have
already been passed through `BasicTokenizer.
Returns:
A list of wordpiece tokens.
"""
text = convert_to_unicode(text)
output_tokens = []
for token in whitespace_tokenize(text):
chars = list(token)
if len(chars) > self.max_input_chars_per_word:
output_tokens.append(self.unk_token)
continue
is_bad = False
start = 0
sub_tokens = []
while start < len(chars):
end = len(chars)
cur_substr = None
while start < end:
substr = "".join(chars[start:end])
if start > 0:
substr = "##" + six.ensure_str(substr)
if substr in self.vocab:
cur_substr = substr
break
end -= 1
if cur_substr is None:
is_bad = True
break
sub_tokens.append(cur_substr)
start = end
if is_bad:
output_tokens.append(self.unk_token)
else:
output_tokens.extend(sub_tokens)
return output_tokens
@lru_cache()
def bytes_to_unicode():
"""
Returns list of utf-8 byte and a corresponding list of unicode strings.
The reversible bpe codes work on unicode strings.
This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
This is a signficant percentage of your normal, say, 32K bpe vocab.
To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
And avoids mapping to whitespace/control characters the bpe code barfs on.
"""
bs = list(range(33, 126 + 1)) + list(range(161, 172 + 1)) + list(range(174, 255 + 1))
cs = bs[:]
n = 0
for b in range(2 ** 8):
if b not in bs:
bs.append(b)
cs.append(2 ** 8 + n)
n += 1
cs = [chr(n) for n in cs]
return dict(zip(bs, cs))
def get_pairs(word):
"""Return set of symbol pairs in a word.
Word is represented as tuple of symbols (symbols being variable-length strings).
"""
pairs = set()
prev_char = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
prev_char = char
return pairs
class BpeEncoder(object):
"""BpeEncoder"""
def __init__(self, encoder_json_file, vocab_bpe_file, errors='replace'):
"""Constructs a BpeEncoder.
Args:
encoder_json_file:
vocab_bpe_file:
"""
self.encoder = self.__get_encoder(encoder_json_file)
self.decoder = {v: k for k, v in self.encoder.items()}
self.errors = errors # how to handle errors in decoding
self.byte_encoder = bytes_to_unicode()
self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
self.bpe_ranks = self.__get_bpe_ranks(vocab_bpe_file)
self.cache = {}
self.pat = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")
def __get_encoder(self, encoder_json_file):
with open(encoder_json_file, 'r') as f:
encoder = json.load(f)
return encoder
def __get_bpe_ranks(self, vocab_bpe_file):
with open(vocab_bpe_file, 'r', encoding="utf-8") as f:
bpe_data = f.read()
bpe_merges = [tuple(merge_str.split()) for merge_str in bpe_data.split('\n')[1:-1]]
bpe_ranks = dict(zip(bpe_merges, range(len(bpe_merges))))
return bpe_ranks
def bpe(self, token):
"""
bpe
"""
if token in self.cache:
return self.cache[token]
word = tuple(token)
pairs = get_pairs(word)
if not pairs:
return token
while True:
bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
if bigram not in self.bpe_ranks:
break
first, second = bigram
new_word = []
i = 0
while i < len(word):
try:
j = word.index(first, i)
new_word.extend(word[i:j])
i = j
except:
new_word.extend(word[i:])
break
if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
new_word.append(first + second)
i += 2
else:
new_word.append(word[i])
i += 1
new_word = tuple(new_word)
word = new_word
if len(word) == 1:
break
else:
pairs = get_pairs(word)
word = ' '.join(word)
self.cache[token] = word
return word
def encode(self, text):
"""
encode
"""
bpe_tokens = []
for token in re.findall(self.pat, text):
token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
return bpe_tokens
def decode(self, tokens):
"""
decode
"""
text = ''.join([self.decoder[token] for token in tokens])
text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors=self.errors)
return text
|
export default function buildUpdateSubjectsController({ updateSubjects }) {
return async function updateSubjectsController(httpRequest) {
try {
const subjectInfo = httpRequest.body;
const { userToken } = httpRequest;
await updateSubjects({
...subjectInfo,
userToken,
});
return {
headers: {
"Content-Type": "application/json",
},
statusCode: 204,
};
} catch (error) {
return {
headers: {
"Content-Type": "application/json",
},
statusCode: 400,
body: { error: error.message },
};
}
};
}
|
/*
Simple DirectMedia Layer
Copyright (C) 1997-2015 Sam Lantinga <[email protected]>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS)
#define SDL_DISABLE_ANALYZE_MACROS 1
#endif
#include "../SDL_internal.h"
/* This file contains portable stdlib functions for SDL */
#include "SDL_stdinc.h"
#include "../libm/math_libm.h"
double
SDL_atan(double x)
{
#ifdef HAVE_ATAN
return atan(x);
#else
return SDL_uclibc_atan(x);
#endif /* HAVE_ATAN */
}
double
SDL_atan2(double x, double y)
{
#if defined(HAVE_ATAN2)
return atan2(x, y);
#else
return SDL_uclibc_atan2(x, y);
#endif /* HAVE_ATAN2 */
}
double
SDL_acos(double val)
{
#if defined(HAVE_ACOS)
return acos(val);
#else
double result;
if (val == -1.0) {
result = M_PI;
} else {
result = SDL_atan(SDL_sqrt(1.0 - val * val) / val);
if (result < 0.0)
{
result += M_PI;
}
}
return result;
#endif
}
double
SDL_asin(double val)
{
#if defined(HAVE_ASIN)
return asin(val);
#else
double result;
if (val == -1.0) {
result = -(M_PI / 2.0);
} else {
result = (M_PI / 2.0) - SDL_acos(val);
}
return result;
#endif
}
double
SDL_ceil(double x)
{
#ifdef HAVE_CEIL
return ceil(x);
#else
double integer = SDL_floor(x);
double fraction = x - integer;
if (fraction > 0.0) {
integer += 1.0;
}
return integer;
#endif /* HAVE_CEIL */
}
double
SDL_copysign(double x, double y)
{
#if defined(HAVE_COPYSIGN)
return copysign(x, y);
#elif defined(HAVE__COPYSIGN)
return _copysign(x, y);
#else
return SDL_uclibc_copysign(x, y);
#endif /* HAVE_COPYSIGN */
}
double
SDL_cos(double x)
{
#if defined(HAVE_COS)
return cos(x);
#else
return SDL_uclibc_cos(x);
#endif /* HAVE_COS */
}
float
SDL_cosf(float x)
{
#ifdef HAVE_COSF
return cosf(x);
#else
return (float)SDL_cos((double)x);
#endif
}
double
SDL_fabs(double x)
{
#if defined(HAVE_FABS)
return fabs(x);
#else
return SDL_uclibc_fabs(x);
#endif /* HAVE_FABS */
}
double
SDL_floor(double x)
{
#if defined(HAVE_FLOOR)
return floor(x);
#else
return SDL_uclibc_floor(x);
#endif /* HAVE_FLOOR */
}
double
SDL_log(double x)
{
#if defined(HAVE_LOG)
return log(x);
#else
return SDL_uclibc_log(x);
#endif /* HAVE_LOG */
}
double
SDL_pow(double x, double y)
{
#if defined(HAVE_POW)
return pow(x, y);
#else
return SDL_uclibc_pow(x, y);
#endif /* HAVE_POW */
}
double
SDL_scalbn(double x, int n)
{
#if defined(HAVE_SCALBN)
return scalbn(x, n);
#elif defined(HAVE__SCALB)
return _scalb(x, n);
#else
return SDL_uclibc_scalbn(x, n);
#endif /* HAVE_SCALBN */
}
double
SDL_sin(double x)
{
#if defined(HAVE_SIN)
return sin(x);
#else
return SDL_uclibc_sin(x);
#endif /* HAVE_SIN */
}
float
SDL_sinf(float x)
{
#ifdef HAVE_SINF
return sinf(x);
#else
return (float)SDL_sin((double)x);
#endif /* HAVE_SINF */
}
double
SDL_sqrt(double x)
{
#if defined(HAVE_SQRT)
return sqrt(x);
#else
return SDL_uclibc_sqrt(x);
#endif
}
float
SDL_sqrtf(float x)
{
#if defined(HAVE_SQRTF)
return sqrtf(x);
#else
return (float)SDL_sqrt((double)x);
#endif
}
double
SDL_tan(double x)
{
#if defined(HAVE_TAN)
return tan(x);
#else
return SDL_uclibc_tan(x);
#endif
}
float
SDL_tanf(float x)
{
#if defined(HAVE_TANF)
return tanf(x);
#else
return (float)SDL_tan((double)x);
#endif
}
int SDL_abs(int x)
{
#ifdef HAVE_ABS
return abs(x);
#else
return ((x) < 0 ? -(x) : (x));
#endif
}
#ifdef HAVE_CTYPE_H
int SDL_isdigit(int x) { return isdigit(x); }
int SDL_isspace(int x) { return isspace(x); }
int SDL_toupper(int x) { return toupper(x); }
int SDL_tolower(int x) { return tolower(x); }
#else
int SDL_isdigit(int x) { return ((x) >= '0') && ((x) <= '9'); }
int SDL_isspace(int x) { return ((x) == ' ') || ((x) == '\t') || ((x) == '\r') || ((x) == '\n') || ((x) == '\f') || ((x) == '\v'); }
int SDL_toupper(int x) { return ((x) >= 'a') && ((x) <= 'z') ? ('A'+((x)-'a')) : (x); }
int SDL_tolower(int x) { return ((x) >= 'A') && ((x) <= 'Z') ? ('a'+((x)-'A')) : (x); }
#endif
#ifndef HAVE_LIBC
/* These are some C runtime intrinsics that need to be defined */
#if defined(_MSC_VER)
#ifndef __FLTUSED__
#define __FLTUSED__
__declspec(selectany) int _fltused = 1;
#endif
/* The optimizer on Visual Studio 2010/2012 generates memcpy() calls */
#if _MSC_VER >= 1600 && defined(_WIN64) && !defined(_DEBUG)
#include <intrin.h>
#pragma function(memcpy)
void * memcpy ( void * destination, const void * source, size_t num )
{
const Uint8 *src = (const Uint8 *)source;
Uint8 *dst = (Uint8 *)destination;
size_t i;
/* All WIN64 architectures have SSE, right? */
if (!((uintptr_t) src & 15) && !((uintptr_t) dst & 15)) {
__m128 values[4];
for (i = num / 64; i--;) {
_mm_prefetch(src, _MM_HINT_NTA);
values[0] = *(__m128 *) (src + 0);
values[1] = *(__m128 *) (src + 16);
values[2] = *(__m128 *) (src + 32);
values[3] = *(__m128 *) (src + 48);
_mm_stream_ps((float *) (dst + 0), values[0]);
_mm_stream_ps((float *) (dst + 16), values[1]);
_mm_stream_ps((float *) (dst + 32), values[2]);
_mm_stream_ps((float *) (dst + 48), values[3]);
src += 64;
dst += 64;
}
num &= 63;
}
while (num--) {
*dst++ = *src++;
}
return destination;
}
#endif /* _MSC_VER == 1600 && defined(_WIN64) && !defined(_DEBUG) */
#ifdef _M_IX86
/* Float to long */
void
__declspec(naked)
_ftol()
{
/* *INDENT-OFF* */
__asm {
push ebp
mov ebp,esp
sub esp,20h
and esp,0FFFFFFF0h
fld st(0)
fst dword ptr [esp+18h]
fistp qword ptr [esp+10h]
fild qword ptr [esp+10h]
mov edx,dword ptr [esp+18h]
mov eax,dword ptr [esp+10h]
test eax,eax
je integer_QnaN_or_zero
arg_is_not_integer_QnaN:
fsubp st(1),st
test edx,edx
jns positive
fstp dword ptr [esp]
mov ecx,dword ptr [esp]
xor ecx,80000000h
add ecx,7FFFFFFFh
adc eax,0
mov edx,dword ptr [esp+14h]
adc edx,0
jmp localexit
positive:
fstp dword ptr [esp]
mov ecx,dword ptr [esp]
add ecx,7FFFFFFFh
sbb eax,0
mov edx,dword ptr [esp+14h]
sbb edx,0
jmp localexit
integer_QnaN_or_zero:
mov edx,dword ptr [esp+14h]
test edx,7FFFFFFFh
jne arg_is_not_integer_QnaN
fstp dword ptr [esp+18h]
fstp dword ptr [esp+18h]
localexit:
leave
ret
}
/* *INDENT-ON* */
}
void
_ftol2_sse()
{
_ftol();
}
/* 64-bit math operators for 32-bit systems */
void
__declspec(naked)
_allmul()
{
/* *INDENT-OFF* */
__asm {
mov eax, dword ptr[esp+8]
mov ecx, dword ptr[esp+10h]
or ecx, eax
mov ecx, dword ptr[esp+0Ch]
jne hard
mov eax, dword ptr[esp+4]
mul ecx
ret 10h
hard:
push ebx
mul ecx
mov ebx, eax
mov eax, dword ptr[esp+8]
mul dword ptr[esp+14h]
add ebx, eax
mov eax, dword ptr[esp+8]
mul ecx
add edx, ebx
pop ebx
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_alldiv()
{
/* *INDENT-OFF* */
__asm {
push edi
push esi
push ebx
xor edi,edi
mov eax,dword ptr [esp+14h]
or eax,eax
jge L1
inc edi
mov edx,dword ptr [esp+10h]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+14h],eax
mov dword ptr [esp+10h],edx
L1:
mov eax,dword ptr [esp+1Ch]
or eax,eax
jge L2
inc edi
mov edx,dword ptr [esp+18h]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+1Ch],eax
mov dword ptr [esp+18h],edx
L2:
or eax,eax
jne L3
mov ecx,dword ptr [esp+18h]
mov eax,dword ptr [esp+14h]
xor edx,edx
div ecx
mov ebx,eax
mov eax,dword ptr [esp+10h]
div ecx
mov edx,ebx
jmp L4
L3:
mov ebx,eax
mov ecx,dword ptr [esp+18h]
mov edx,dword ptr [esp+14h]
mov eax,dword ptr [esp+10h]
L5:
shr ebx,1
rcr ecx,1
shr edx,1
rcr eax,1
or ebx,ebx
jne L5
div ecx
mov esi,eax
mul dword ptr [esp+1Ch]
mov ecx,eax
mov eax,dword ptr [esp+18h]
mul esi
add edx,ecx
jb L6
cmp edx,dword ptr [esp+14h]
ja L6
jb L7
cmp eax,dword ptr [esp+10h]
jbe L7
L6:
dec esi
L7:
xor edx,edx
mov eax,esi
L4:
dec edi
jne L8
neg edx
neg eax
sbb edx,0
L8:
pop ebx
pop esi
pop edi
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_aulldiv()
{
/* *INDENT-OFF* */
__asm {
push ebx
push esi
mov eax,dword ptr [esp+18h]
or eax,eax
jne L1
mov ecx,dword ptr [esp+14h]
mov eax,dword ptr [esp+10h]
xor edx,edx
div ecx
mov ebx,eax
mov eax,dword ptr [esp+0Ch]
div ecx
mov edx,ebx
jmp L2
L1:
mov ecx,eax
mov ebx,dword ptr [esp+14h]
mov edx,dword ptr [esp+10h]
mov eax,dword ptr [esp+0Ch]
L3:
shr ecx,1
rcr ebx,1
shr edx,1
rcr eax,1
or ecx,ecx
jne L3
div ebx
mov esi,eax
mul dword ptr [esp+18h]
mov ecx,eax
mov eax,dword ptr [esp+14h]
mul esi
add edx,ecx
jb L4
cmp edx,dword ptr [esp+10h]
ja L4
jb L5
cmp eax,dword ptr [esp+0Ch]
jbe L5
L4:
dec esi
L5:
xor edx,edx
mov eax,esi
L2:
pop esi
pop ebx
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_allrem()
{
/* *INDENT-OFF* */
__asm {
push ebx
push edi
xor edi,edi
mov eax,dword ptr [esp+10h]
or eax,eax
jge L1
inc edi
mov edx,dword ptr [esp+0Ch]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+10h],eax
mov dword ptr [esp+0Ch],edx
L1:
mov eax,dword ptr [esp+18h]
or eax,eax
jge L2
mov edx,dword ptr [esp+14h]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+18h],eax
mov dword ptr [esp+14h],edx
L2:
or eax,eax
jne L3
mov ecx,dword ptr [esp+14h]
mov eax,dword ptr [esp+10h]
xor edx,edx
div ecx
mov eax,dword ptr [esp+0Ch]
div ecx
mov eax,edx
xor edx,edx
dec edi
jns L4
jmp L8
L3:
mov ebx,eax
mov ecx,dword ptr [esp+14h]
mov edx,dword ptr [esp+10h]
mov eax,dword ptr [esp+0Ch]
L5:
shr ebx,1
rcr ecx,1
shr edx,1
rcr eax,1
or ebx,ebx
jne L5
div ecx
mov ecx,eax
mul dword ptr [esp+18h]
xchg eax,ecx
mul dword ptr [esp+14h]
add edx,ecx
jb L6
cmp edx,dword ptr [esp+10h]
ja L6
jb L7
cmp eax,dword ptr [esp+0Ch]
jbe L7
L6:
sub eax,dword ptr [esp+14h]
sbb edx,dword ptr [esp+18h]
L7:
sub eax,dword ptr [esp+0Ch]
sbb edx,dword ptr [esp+10h]
dec edi
jns L8
L4:
neg edx
neg eax
sbb edx,0
L8:
pop edi
pop ebx
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_aullrem()
{
/* *INDENT-OFF* */
__asm {
push ebx
mov eax,dword ptr [esp+14h]
or eax,eax
jne L1
mov ecx,dword ptr [esp+10h]
mov eax,dword ptr [esp+0Ch]
xor edx,edx
div ecx
mov eax,dword ptr [esp+8]
div ecx
mov eax,edx
xor edx,edx
jmp L2
L1:
mov ecx,eax
mov ebx,dword ptr [esp+10h]
mov edx,dword ptr [esp+0Ch]
mov eax,dword ptr [esp+8]
L3:
shr ecx,1
rcr ebx,1
shr edx,1
rcr eax,1
or ecx,ecx
jne L3
div ebx
mov ecx,eax
mul dword ptr [esp+14h]
xchg eax,ecx
mul dword ptr [esp+10h]
add edx,ecx
jb L4
cmp edx,dword ptr [esp+0Ch]
ja L4
jb L5
cmp eax,dword ptr [esp+8]
jbe L5
L4:
sub eax,dword ptr [esp+10h]
sbb edx,dword ptr [esp+14h]
L5:
sub eax,dword ptr [esp+8]
sbb edx,dword ptr [esp+0Ch]
neg edx
neg eax
sbb edx,0
L2:
pop ebx
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_alldvrm()
{
/* *INDENT-OFF* */
__asm {
push edi
push esi
push ebp
xor edi,edi
xor ebp,ebp
mov eax,dword ptr [esp+14h]
or eax,eax
jge L1
inc edi
inc ebp
mov edx,dword ptr [esp+10h]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+14h],eax
mov dword ptr [esp+10h],edx
L1:
mov eax,dword ptr [esp+1Ch]
or eax,eax
jge L2
inc edi
mov edx,dword ptr [esp+18h]
neg eax
neg edx
sbb eax,0
mov dword ptr [esp+1Ch],eax
mov dword ptr [esp+18h],edx
L2:
or eax,eax
jne L3
mov ecx,dword ptr [esp+18h]
mov eax,dword ptr [esp+14h]
xor edx,edx
div ecx
mov ebx,eax
mov eax,dword ptr [esp+10h]
div ecx
mov esi,eax
mov eax,ebx
mul dword ptr [esp+18h]
mov ecx,eax
mov eax,esi
mul dword ptr [esp+18h]
add edx,ecx
jmp L4
L3:
mov ebx,eax
mov ecx,dword ptr [esp+18h]
mov edx,dword ptr [esp+14h]
mov eax,dword ptr [esp+10h]
L5:
shr ebx,1
rcr ecx,1
shr edx,1
rcr eax,1
or ebx,ebx
jne L5
div ecx
mov esi,eax
mul dword ptr [esp+1Ch]
mov ecx,eax
mov eax,dword ptr [esp+18h]
mul esi
add edx,ecx
jb L6
cmp edx,dword ptr [esp+14h]
ja L6
jb L7
cmp eax,dword ptr [esp+10h]
jbe L7
L6:
dec esi
sub eax,dword ptr [esp+18h]
sbb edx,dword ptr [esp+1Ch]
L7:
xor ebx,ebx
L4:
sub eax,dword ptr [esp+10h]
sbb edx,dword ptr [esp+14h]
dec ebp
jns L9
neg edx
neg eax
sbb edx,0
L9:
mov ecx,edx
mov edx,ebx
mov ebx,ecx
mov ecx,eax
mov eax,esi
dec edi
jne L8
neg edx
neg eax
sbb edx,0
L8:
pop ebp
pop esi
pop edi
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_aulldvrm()
{
/* *INDENT-OFF* */
__asm {
push esi
mov eax,dword ptr [esp+14h]
or eax,eax
jne L1
mov ecx,dword ptr [esp+10h]
mov eax,dword ptr [esp+0Ch]
xor edx,edx
div ecx
mov ebx,eax
mov eax,dword ptr [esp+8]
div ecx
mov esi,eax
mov eax,ebx
mul dword ptr [esp+10h]
mov ecx,eax
mov eax,esi
mul dword ptr [esp+10h]
add edx,ecx
jmp L2
L1:
mov ecx,eax
mov ebx,dword ptr [esp+10h]
mov edx,dword ptr [esp+0Ch]
mov eax,dword ptr [esp+8]
L3:
shr ecx,1
rcr ebx,1
shr edx,1
rcr eax,1
or ecx,ecx
jne L3
div ebx
mov esi,eax
mul dword ptr [esp+14h]
mov ecx,eax
mov eax,dword ptr [esp+10h]
mul esi
add edx,ecx
jb L4
cmp edx,dword ptr [esp+0Ch]
ja L4
jb L5
cmp eax,dword ptr [esp+8]
jbe L5
L4:
dec esi
sub eax,dword ptr [esp+10h]
sbb edx,dword ptr [esp+14h]
L5:
xor ebx,ebx
L2:
sub eax,dword ptr [esp+8]
sbb edx,dword ptr [esp+0Ch]
neg edx
neg eax
sbb edx,0
mov ecx,edx
mov edx,ebx
mov ebx,ecx
mov ecx,eax
mov eax,esi
pop esi
ret 10h
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_allshl()
{
/* *INDENT-OFF* */
__asm {
cmp cl,40h
jae RETZERO
cmp cl,20h
jae MORE32
shld edx,eax,cl
shl eax,cl
ret
MORE32:
mov edx,eax
xor eax,eax
and cl,1Fh
shl edx,cl
ret
RETZERO:
xor eax,eax
xor edx,edx
ret
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_allshr()
{
/* *INDENT-OFF* */
__asm {
cmp cl,40h
jae RETZERO
cmp cl,20h
jae MORE32
shrd eax,edx,cl
sar edx,cl
ret
MORE32:
mov eax,edx
xor edx,edx
and cl,1Fh
sar eax,cl
ret
RETZERO:
xor eax,eax
xor edx,edx
ret
}
/* *INDENT-ON* */
}
void
__declspec(naked)
_aullshr()
{
/* *INDENT-OFF* */
__asm {
cmp cl,40h
jae RETZERO
cmp cl,20h
jae MORE32
shrd eax,edx,cl
shr edx,cl
ret
MORE32:
mov eax,edx
xor edx,edx
and cl,1Fh
shr eax,cl
ret
RETZERO:
xor eax,eax
xor edx,edx
ret
}
/* *INDENT-ON* */
}
#endif /* _M_IX86 */
#endif /* MSC_VER */
#endif /* !HAVE_LIBC */
/* vi: set ts=4 sw=4 expandtab: */
|
import { getNPMConfig } from '@tech_query/node-toolkit';
import Browser from './Browser';
const stack = [ ];
/**
* Puppeteer API
*/
export default class Puppeteer {
/**
* @return {String} A path where Puppeteer expects to find installed Firefox
*/
static executablePath() { return getNPMConfig('firefox'); }
/**
* Launch a browser instance with given arguments.
* The browser will be closed when the parent NodeJS process is closed.
*
* @param {object} [options] Set of configurable options to set on the browser
* @param {string} [options.executablePath = true] Path to a Firefox executable to run.
* If `executablePath` is a relative path,
* then it is resolved relative to current working directory.
* @param {boolean} [options.headless = true] Whether to run browser in headless mode
* @param {string} [options.userDataDir = ''] Path to a User Data Directory
* @param {object} [options.throttling] Network Throttling
*
* @return {Browser}
*/
static async launch({
executablePath = '', headless = true, userDataDir = '', throttling
} = { }) {
const launchCfg = {
url: 'about:blank',
bin: executablePath || this.executablePath(),
args: [ ]
};
if ( headless ) launchCfg.args.push('--headless');
if ( userDataDir ) launchCfg.args.push('--profile', userDataDir);
if ( throttling )
throttling.downloadThroughput = throttling.downloadThroughput || 75000,
throttling.uploadThroughput = throttling.uploadThroughput || 25000,
throttling.latency = throttling.latency || 100;
return stack[stack.push(new Browser(launchCfg, throttling)) - 1];
}
/**
* @param {?Error} error
*/
static async exit(error) {
await Promise.all( stack.map(browser => browser.close()) );
if (!(error instanceof Error)) process.exit(0);
console.error( error );
process.exit(1);
}
}
for (let event of ['uncaughtException', 'unhandledRejection', 'SIGINT', 'exit'])
process.on(event, Puppeteer.exit);
/**
* Serializable value
*
* @typedef {number|boolean|string|object|array} Serializable
*
* @see {@link
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Description|Promise}
*/
|
const path = require('path');
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');
module.exports = {
entry: {
app: path.resolve(process.cwd(),'./client/index.js'),
},
resolve: {
extensions: ['.js', '.jsx'],
},
module: {
rules: [
{ test: /\.jsx?$/, loader: 'babel-loader', exclude: /node_modules/ },
{
test: /\.(eot|svg|ttf|woff|woff2)$/,
loader: 'file-loader?name=public/fonts/[name].[ext]'
}
]
},
plugins: [
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
DEBUG: false,
}),
new HtmlWebpackPlugin({
template: path.resolve(process.cwd(), './client/index.html'),
filename: 'index.html',
inject: 'body',
})
]
};
|
/*
* Copyright (C) 2019 Open Source Robotics Foundation
*
* 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.
*
*/
#ifndef POLYGON_H
#define POLYGON_H
#include <map>
#include <string>
#include <vector>
#include <yaml-cpp/yaml.h>
#include <QPolygonF>
#include "param.h"
class Polygon
{
public:
std::vector<int> vertices;
bool selected = false;
std::map<std::string, Param> params;
enum Type
{
UNDEFINED = 0,
FLOOR,
ZONE,
ROI,
HOLE
} type = UNDEFINED;
Polygon();
~Polygon();
void from_yaml(const YAML::Node& data, const Type polygon_type);
YAML::Node to_yaml() const;
void remove_vertex(const int vertex_idx);
struct EdgeDragPolygon
{
QPolygonF polygon;
int movable_vertex = -1;
};
void set_param(const std::string& name, const std::string& value);
void create_required_parameters();
template<typename T>
void create_param_if_needed(
const std::string& name,
const Param::Type& param_type,
const T& param_value);
};
#endif
|
// Copyright (c) 2017 The GRINC developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_BIP38_H
#define BITCOIN_BIP38_H
#include "pubkey.h"
#include "uint256.h"
#include <string>
/** 39 bytes - 78 characters
* 1) Prefix - 2 bytes - 4 chars - strKey[0..3]
* 2) Flagbyte - 1 byte - 2 chars - strKey[4..5]
* 3) addresshash - 4 bytes - 8 chars - strKey[6..13]
* 4) Owner Entropy - 8 bytes - 16 chars - strKey[14..29]
* 5) Encrypted Part 1 - 8 bytes - 16 chars - strKey[30..45]
* 6) Encrypted Part 2 - 16 bytes - 32 chars - strKey[46..77]
*/
void DecryptAES(uint256 encryptedIn, uint256 decryptionKey, uint256& output);
void ComputePreFactor(std::string strPassphrase, std::string strSalt, uint256& prefactor);
void ComputePassfactor(std::string ownersalt, uint256 prefactor, uint256& passfactor);
bool ComputePasspoint(uint256 passfactor, CPubKey& passpoint);
void ComputeSeedBPass(CPubKey passpoint, std::string strAddressHash, std::string strOwnerSalt, uint512& seedBPass);
void ComputeFactorB(uint256 seedB, uint256& factorB);
std::string BIP38_Encrypt(std::string strAddress, std::string strPassphrase, uint256 privKey, bool fCompressed);
bool BIP38_Decrypt(std::string strPassphrase, std::string strEncryptedKey, uint256& privKey, bool& fCompressed);
std::string AddressToBip38Hash(std::string address);
#endif // BIP38_H
|
// This array contains the coordinates for all bus stops between MIT and Harvard
const busStops = [
[-71.093729, 42.359244],
[-71.094915, 42.360175],
[-71.0958, 42.360698],
[-71.099558, 42.362953],
[-71.103476, 42.365248],
[-71.106067, 42.366806],
[-71.108717, 42.368355],
[-71.110799, 42.369192],
[-71.113095, 42.370218],
[-71.115476, 42.372085],
[-71.117585, 42.373016],
[-71.118625, 42.374863],
];
// TODO: add your own access token
mapboxgl.accessToken =
'pk.eyJ1IjoidGVzdHVzZXIxMDAwIiwiYSI6ImNraDkzZ2pkMzAzMHoycnBmMXpvZ3UwZnMifQ.jAE4YsPeAJv50VK92NSpOQ';
// TODO: create the map object using mapboxgl.map() function
let map = new mapboxgl.Map({
container: 'map',
style: 'mapbox://styles/mapbox/streets-v11',
center: [-71.104081, 42.365554],
zoom: 14,
});
// TODO: add a marker to the map
let marker = new mapboxgl.Marker().setLngLat([-71.092761, 42.357575]).addTo(map);
// counter here represents the index of the current bus stop
let counter = 0;
function move() {
// TODO: move the marker on the map every 1000ms. Use the function marker.setLngLat() to update the marker coordinates
// Use counter to access bus stops in the array busStops
setTimeout(() => {
if (counter >= busStops.length) return;
marker.setLngLat(busStops[counter]);
counter++;
move();
}, 1000);
}
// Do not edit code past this point
if (typeof module !== 'undefined') {
module.exports = { move, counter, marker, busStops };
}
|
const { logParams, getCmdParams } = require("./utils/cmd");
const { genRandomUser } = require("./utils/genTools");
const {
createNewUser: createNewUserController
} = require("../../api/user").userControllers;
const {
createNewAccount: createNewAccountController
} = require("../../api/account").accountControllers;
const { Spinner } = require("cli-spinner");
//wrap controller to throw errors
const createNewUser = async userDetails => {
const { userID, error } = await createNewUserController(userDetails);
if (error) throw new Error(error.message);
return { userID };
};
//wrap controller to throw errors
const createNewAccount = async accountDetails => {
const { accountID, error } = await createNewAccountController(
accountDetails
);
if (error) throw new Error(error.message);
return { accountID };
};
//given the number of accounts to create a user plus userID
//creates transfer accounts for user
const createAccountsForUserFn = numAccountsPerUser => async accountDetails => {
const acctNums = await Promise.all(
Array.from({ length: numAccountsPerUser }).map(() =>
createNewAccount(accountDetails)
)
);
return acctNums.map(({ accountID }) => accountID);
};
const seedUsersAccounts = async (users, accountsPerUser) => {
const createAccounts = createAccountsForUserFn(accountsPerUser);
while (users > 0) {
try {
const newUser = genRandomUser();
const { userID } = await createNewUser(newUser);
await createAccounts({ userID });
users--;
} catch (err) {
console.error(err.message || err);
}
}
};
//startingPt
const main = async () => {
const spinner = new Spinner();
spinner.setSpinnerString(0);
const { users, accountsPerUser } = getCmdParams();
logParams({ users, accountsPerUser });
spinner.setSpinnerTitle("creating users & accounts...");
spinner.start();
await seedUsersAccounts(users, accountsPerUser);
spinner.stop(true);
console.log("done");
};
main().catch(err => console.error(err));
|
/**************************************************************************
* AW5306_Drv.h
*
* AW5306 Driver code version 1.0
*
* Create Date : 2012/06/25
*
* Modify Date :
*
* Create by : wuhaijun
*
**************************************************************************/
#ifndef AW5306_DRV_H
#define AW5306_DRV_H
//#define WATER_PROOF //water solution
#define MAX_POINT 5
#define NUM_TX 21 // TX number of TOUCH IC
#define NUM_RX 12 // RX number of TOUCH IC
//#define NEWBASE_PROCESS //new base process need test!!!
#define ABS(X) ((X > 0) ? (X) : (-X))
typedef enum{
RawDataMode = 0,
DeltaMode,
MonitorMode
}enumWorkMode;
typedef enum{
BASE_INITIAL,
BASE_FAST_TRACE,
BASE_STABLE,
TEMP_DRIFT
} CompensateMode;
typedef struct {
unsigned short Base[NUM_TX][NUM_RX];
unsigned short ChipBase[NUM_TX][NUM_RX];
signed char Flag[NUM_TX][NUM_RX];
signed char BaseCnt[NUM_TX][NUM_RX];
unsigned char CompensateFlag;
unsigned char TraceTempIncCnt;
unsigned char TraceTempDecCnt;
unsigned char CompensateStateFrameCnt;
short LastMaxDiff;
CompensateMode CompensateState;
unsigned int InitialFrameCnt;
unsigned char PosBigAreaTouchFlag;
unsigned char NegBigAreaTouchFlag;
unsigned char BigAreaFirstFlag;
unsigned char BigAreaChangeFlag;
unsigned short BigTouchFrame;
unsigned short FrameCnt;
unsigned char LongStableCnt;
unsigned char PosPeakCnt;
unsigned char NegPeakCnt;
unsigned char PeakCheckFrameCnt;
unsigned char BaseFrozen;
unsigned char PosPeakCompensateCnt[MAX_POINT];
unsigned char NegPeakCompensateCnt[MAX_POINT];
}STRUCTBASE;
typedef struct {
unsigned char Peak[MAX_POINT][2];
unsigned char LastPeak[MAX_POINT][2];
unsigned char NegPeak[MAX_POINT][2];
unsigned char CurrentPointNum;
unsigned char CurrentNegPointNum;
unsigned char LastPointNum;
}STRUCTPEAK;
typedef struct {
unsigned short X,Y; // X,Y coordinate
unsigned char PointID; // Assigned point ID
unsigned char Event; // Event of current point
}STRUCTPOINT;
typedef struct {
STRUCTPOINT PointInfo[MAX_POINT];
STRUCTPOINT RptPoint[MAX_POINT];
unsigned char PointNum;
unsigned char LastPointNum;
unsigned char NegPointNum;
unsigned char FilterPointCnt;
unsigned char FirstLiftUpFlag;
unsigned char TouchStatus;
unsigned char PointHoldCnt[MAX_POINT];
unsigned char PointPressCnt[MAX_POINT];
}STRUCTFRAME;
typedef struct {
unsigned char fileflag[14];
unsigned char TXOFFSET[(NUM_TX+1)/2];
unsigned char RXOFFSET[(NUM_RX+1)/2];
unsigned char TXCAC[NUM_TX];
unsigned char RXCAC[NUM_RX];
unsigned char TXGAIN[NUM_TX];
short SOFTOFFSET[NUM_TX][NUM_RX];
}STRUCTCALI;
void AW5306_TP_Init(void);
void AW5306_TP_Reinit(void);
void AW5306_Sleep(void);
char AW5306_TouchProcess(void);
void AW5306_ChargeMode(char mode);
unsigned char AW5306_GetPointNum(void);
unsigned char AW5306_GetPeakNum(void);
char AW5306_GetPoint(int *x,int *y, int *id, int *event,char Index);
void AW5306_GetBase(unsigned short *data, char x,char y);
void AW5306_GetDiff(short *data, char x,char y);
char AW5306_GetPeak(unsigned char *x,unsigned char *y,unsigned char Index);
char AW5306_GetNegPeak(unsigned char *x,unsigned char *y,unsigned char Index);
char AW5306_GetCalcPoint(unsigned short *x,unsigned short *y,unsigned char Index);
char AW5306_CLB(void);
void AW5306_CLB_GetCfg(void);
void AW5306_CLB_WriteCfg(void);
void TP_Force_Calibration(void);
void FreqScan(unsigned char BaseFreq);
#endif
|
'''
Copyright (c) 2021, Štěpán Beneš
Basic Convolutional Autoencoder, few layers deeper than the initial one
'''
import numpy as np
from Models.Autoencoders.BaseModel import BaseModel
from keras.layers import Input, Reshape, Dense, Flatten
from keras.layers import Activation, Conv2D, MaxPooling2D, UpSampling2D, PReLU
from keras.initializers import Constant
from keras.models import Model
from keras.callbacks import History
class BasicAutoencoderDeeper(BaseModel):
def __init__(self):
super().__init__()
self.name = "BasicAutoencoderDeeper"
return
def create_net(self, input_shape):
net_input = Input(shape=input_shape)
x = Conv2D(self.filters, (3, 3), padding='same')(net_input)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
self.encoded = MaxPooling2D((2, 2), padding='same')(x)
# Keep the encoder part
self.encoder = Model(net_input, self.encoded)
# And now the decoder part
x = Conv2D(self.filters, (3, 3), padding='same')(self.encoded)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(self.filters, (3, 3), padding='same')(x)
x = PReLU(alpha_initializer=Constant(value=0.25))(x)
x = UpSampling2D((2, 2))(x)
self.decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)
self.model = Model(net_input, self.decoded)
return
|
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = makeNewBuild;
var graphql = _interopRequireWildcard(require("graphql"));
var _graphqlParseResolveInfo = require("graphql-parse-resolve-info");
var _debug = _interopRequireDefault(require("debug"));
var _pluralize = _interopRequireDefault(require("pluralize"));
var _lru = _interopRequireDefault(require("@graphile/lru"));
var _semver = _interopRequireDefault(require("semver"));
var _utils = require("./utils");
var _swallowError = _interopRequireDefault(require("./swallowError"));
var _resolveNode = _interopRequireDefault(require("./resolveNode"));
var _Live = require("./Live");
var _extend = _interopRequireWildcard(require("./extend"));
var _chalk = _interopRequireDefault(require("chalk"));
var _crypto = require("crypto");
var _package = require("../package.json");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
let recurseDataGeneratorsForFieldWarned = false;
const isString = str => typeof str === "string";
const isDev = ["test", "development"].indexOf(process.env.NODE_ENV) >= 0;
const debug = (0, _debug.default)("graphile-build");
/*
* This should be more than enough for normal usage. If you come under a
* sophisticated attack then the attacker can empty this of useful values (with
* a lot of work) but because we use SHA1 hashes under the covers the aliases
* will still be consistent even after the LRU cache is exhausted. And SHA1 can
* produce half a million hashes per second on my machine, the LRU only gives
* us a 10x speedup!
*/
const hashCache = new _lru.default({
maxLength: 100000
});
/*
* This function must never return a string longer than 56 characters.
*
* This function must only output alphanumeric and underscore characters.
*
* Collisions in SHA1 aren't problematic here (for us; they will be problematic
* for the user deliberately causing them, but that's their own fault!), so
* we'll happily take the performance boost over SHA256.
*/
function hashFieldAlias(str) {
const precomputed = hashCache.get(str);
if (precomputed) return precomputed;
const hash = (0, _crypto.createHash)("sha1").update(str).digest("hex");
hashCache.set(str, hash);
return hash;
}
/*
* This function may be replaced at any time, but all versions of it will
* always return a representation of `alias` (a valid GraphQL identifier)
* that:
*
* 1. won't conflict with normal GraphQL field names
* 2. won't be over 60 characters long (allows for systems with alias length limits, such as PG)
* 3. will give the same value when called multiple times within the same GraphQL query
* 4. matches the regex /^[@!-_A-Za-z0-9]+$/
* 5. will not be prefixed with `__` (as that will conflict with other Graphile internals)
*
* It does not guarantee that this alias will be human readable!
*/
function getSafeAliasFromAlias(alias) {
if (alias.length <= 60 && !alias.startsWith("@")) {
// Use the `@` to prevent conflicting with normal GraphQL field names, but otherwise let it through verbatim.
return `@${alias}`;
} else if (alias.length > 1024) {
throw new Error(`GraphQL alias '${alias}' is too long, use shorter aliases (max length 1024).`);
} else {
return `@@${hashFieldAlias(alias)}`;
}
}
/*
* This provides a "safe" version of the alias from ResolveInfo, guaranteed to
* never be longer than 60 characters. This makes it suitable as a PostgreSQL
* identifier.
*/
function getSafeAliasFromResolveInfo(resolveInfo) {
const alias = (0, _graphqlParseResolveInfo.getAliasFromResolveInfo)(resolveInfo);
return getSafeAliasFromAlias(alias);
}
function getNameFromType(Type) {
if (Type instanceof GraphQLSchema) {
return "schema";
} else {
return Type.name;
}
}
const {
GraphQLSchema,
GraphQLInterfaceType,
GraphQLObjectType,
GraphQLInputObjectType,
GraphQLEnumType,
GraphQLUnionType,
getNamedType,
isCompositeType,
isAbstractType
} = graphql;
const mergeData = (data, gen, ReturnType, arg) => {
const results = ensureArray(gen(arg, ReturnType, data));
if (!results) {
return;
}
for (let resultIndex = 0, resultCount = results.length; resultIndex < resultCount; resultIndex++) {
const result = results[resultIndex];
const keys = Object.keys(result);
for (let i = 0, l = keys.length; i < l; i++) {
const k = keys[i];
data[k] = data[k] || [];
const value = result[k];
const newData = ensureArray(value);
if (newData) {
data[k].push(...newData);
}
}
}
};
const knownTypes = [GraphQLSchema, GraphQLObjectType, GraphQLInputObjectType, GraphQLEnumType, GraphQLUnionType];
const knownTypeNames = knownTypes.map(k => k.name);
function ensureArray(val) {
if (val == null) {
return;
} else if (Array.isArray(val)) {
// $FlowFixMe
return val;
} else {
return [val];
}
} // eslint-disable-next-line no-unused-vars
let ensureName = _fn => {};
if (["development", "test"].indexOf(process.env.NODE_ENV) >= 0) {
ensureName = fn => {
// $FlowFixMe: displayName
if (isDev && !fn.displayName && !fn.name && debug.enabled) {
// eslint-disable-next-line no-console
console.trace("WARNING: you've added a function with no name as an argDataGenerator, doing so may make debugging more challenging");
}
};
}
function makeNewBuild(builder) {
const allTypes = {
Int: graphql.GraphQLInt,
Float: graphql.GraphQLFloat,
String: graphql.GraphQLString,
Boolean: graphql.GraphQLBoolean,
ID: graphql.GraphQLID
};
const allTypesSources = {
Int: "GraphQL Built-in",
Float: "GraphQL Built-in",
String: "GraphQL Built-in",
Boolean: "GraphQL Built-in",
ID: "GraphQL Built-in"
}; // Every object type gets fieldData associated with each of its
// fields.
// When a field is defined, it may add to this field data.
// When something resolves referencing this type, the resolver may
// request the fieldData, e.g. to perform optimisations.
// fieldData is an object whose keys are the fields on this
// GraphQLObjectType and whose values are an object (whose keys are
// arbitrary namespaced keys and whose values are arrays of
// information of this kind)
const fieldDataGeneratorsByFieldNameByType = new Map();
const fieldArgDataGeneratorsByFieldNameByType = new Map();
return {
options: builder.options,
graphileBuildVersion: _package.version,
versions: {
graphql: require("graphql/package.json").version,
"graphile-build": _package.version
},
hasVersion(packageName, range, options = {
includePrerelease: true
}) {
const packageVersion = this.versions[packageName];
if (!packageVersion) return false;
return _semver.default.satisfies(packageVersion, range, options);
},
graphql,
parseResolveInfo: _graphqlParseResolveInfo.parseResolveInfo,
simplifyParsedResolveInfoFragmentWithType: _graphqlParseResolveInfo.simplifyParsedResolveInfoFragmentWithType,
getSafeAliasFromAlias,
getAliasFromResolveInfo: getSafeAliasFromResolveInfo,
// DEPRECATED: do not use this!
getSafeAliasFromResolveInfo,
resolveAlias(data, _args, _context, resolveInfo) {
const alias = getSafeAliasFromResolveInfo(resolveInfo);
return data[alias];
},
addType(type, origin) {
if (!type.name) {
throw new Error(`addType must only be called with named types, try using require('graphql').getNamedType`);
}
const newTypeSource = origin || ( // 'this' is typically only available after the build is finalized
this ? `'addType' call during hook '${this.status.currentHookName}'` : null);
if (allTypes[type.name]) {
if (allTypes[type.name] !== type) {
const oldTypeSource = allTypesSources[type.name];
const firstEntityDetails = !oldTypeSource ? "The first type was registered from an unknown origin." : `The first entity was:\n\n${(0, _extend.indent)(_chalk.default.magenta(oldTypeSource))}`;
const secondEntityDetails = !newTypeSource ? "The second type was registered from an unknown origin." : `The second entity was:\n\n${(0, _extend.indent)(_chalk.default.yellow(newTypeSource))}`;
throw new Error(`A type naming conflict has occurred - two entities have tried to define the same type '${_chalk.default.bold(type.name)}'.\n\n${(0, _extend.indent)(firstEntityDetails)}\n\n${(0, _extend.indent)(secondEntityDetails)}`);
}
} else {
allTypes[type.name] = type;
allTypesSources[type.name] = newTypeSource;
}
},
getTypeByName(typeName) {
return allTypes[typeName];
},
extend: _extend.default,
newWithHooks(Type, spec, inScope, performNonEmptyFieldsCheck = false) {
const scope = inScope || {};
if (!inScope) {
// eslint-disable-next-line no-console
console.warn(`No scope was provided to new ${Type.name}[name=${spec.name}], it's highly recommended that you add a scope so other hooks can easily reference your object - please check usage of 'newWithHooks'. To mute this message, just pass an empty object.`);
}
if (!Type) {
throw new Error("No type specified!");
}
if (!this.newWithHooks) {
throw new Error("Please do not generate the schema during the build building phase, use 'init' instead");
}
const fieldDataGeneratorsByFieldName = {};
const fieldArgDataGeneratorsByFieldName = {};
let newSpec = spec;
if (knownTypes.indexOf(Type) === -1 && knownTypeNames.indexOf(Type.name) >= 0) {
throw new Error(`GraphQL conflict for '${Type.name}' detected! Multiple versions of graphql exist in your node_modules?`);
}
if (Type === GraphQLSchema) {
newSpec = builder.applyHooks(this, "GraphQLSchema", newSpec, {
type: "GraphQLSchema",
scope
});
} else if (Type === GraphQLObjectType) {
const addDataGeneratorForField = (fieldName, fn) => {
// $FlowFixMe: displayName
fn.displayName = // $FlowFixMe: displayName
fn.displayName || `${getNameFromType(Self)}:${fieldName}[${fn.name || "anonymous"}]`;
fieldDataGeneratorsByFieldName[fieldName] = fieldDataGeneratorsByFieldName[fieldName] || [];
fieldDataGeneratorsByFieldName[fieldName].push(fn);
};
const recurseDataGeneratorsForField = (fieldName, iKnowWhatIAmDoing) => {
/*
* Recursing data generators is not safe in general; however there
* are certain exceptions - for example when you know there are no
* "dynamic" data generator fields - e.g. where the GraphQL alias is
* not used at all. In PostGraphile the only case of this is the
* PageInfo object as none of the fields accept arguments, and they
* do not rely on the GraphQL query alias to store the result.
*/
if (!iKnowWhatIAmDoing && !recurseDataGeneratorsForFieldWarned) {
recurseDataGeneratorsForFieldWarned = true; // eslint-disable-next-line no-console
console.error("Use of `recurseDataGeneratorsForField` is NOT SAFE. e.g. `{n1: node { a: field1 }, n2: node { a: field2 } }` cannot resolve correctly.");
}
const fn = (parsedResolveInfoFragment, ReturnType, ...rest) => {
const {
args
} = parsedResolveInfoFragment;
const {
fields
} = this.simplifyParsedResolveInfoFragmentWithType(parsedResolveInfoFragment, ReturnType);
const results = [];
const StrippedType = getNamedType(ReturnType);
const fieldDataGeneratorsByFieldName = fieldDataGeneratorsByFieldNameByType.get(StrippedType);
const argDataGeneratorsForSelfByFieldName = fieldArgDataGeneratorsByFieldNameByType.get(Self);
if (argDataGeneratorsForSelfByFieldName) {
const argDataGenerators = argDataGeneratorsForSelfByFieldName[fieldName];
for (let genIndex = 0, genCount = argDataGenerators.length; genIndex < genCount; genIndex++) {
const gen = argDataGenerators[genIndex];
const local = ensureArray(gen(args, ReturnType, ...rest));
if (local) {
results.push(...local);
}
}
}
if (fieldDataGeneratorsByFieldName && isCompositeType(StrippedType) && !isAbstractType(StrippedType)) {
const typeFields = StrippedType.getFields();
const keys = Object.keys(fields);
for (let keyIndex = 0, keyCount = keys.length; keyIndex < keyCount; keyIndex++) {
const alias = keys[keyIndex];
const field = fields[alias]; // Run generators with `field` as the `parsedResolveInfoFragment`, pushing results to `results`
const gens = fieldDataGeneratorsByFieldName[field.name];
if (gens) {
for (let genIndex = 0, genCount = gens.length; genIndex < genCount; genIndex++) {
const gen = gens[genIndex];
const local = ensureArray(gen(field, typeFields[field.name].type, ...rest));
if (local) {
results.push(...local);
}
}
}
}
}
return results;
};
fn.displayName = `recurseDataGeneratorsForField(${getNameFromType(Self)}:${fieldName})`;
addDataGeneratorForField(fieldName, fn); // get type from field, get
};
const commonContext = {
type: "GraphQLObjectType",
scope
};
newSpec = builder.applyHooks(this, "GraphQLObjectType", newSpec, { ...commonContext,
addDataGeneratorForField,
recurseDataGeneratorsForField
}, `|${newSpec.name}`);
const rawSpec = newSpec;
newSpec = { ...newSpec,
interfaces: () => {
const interfacesContext = { ...commonContext,
Self,
GraphQLObjectType: rawSpec
};
let rawInterfaces = rawSpec.interfaces || [];
if (typeof rawInterfaces === "function") {
rawInterfaces = rawInterfaces(interfacesContext);
}
return builder.applyHooks(this, "GraphQLObjectType:interfaces", rawInterfaces, interfacesContext, `|${getNameFromType(Self)}`);
},
fields: () => {
const processedFields = [];
const fieldsContext = { ...commonContext,
addDataGeneratorForField,
recurseDataGeneratorsForField,
Self,
GraphQLObjectType: rawSpec,
fieldWithHooks: (fieldName, spec, fieldScope) => {
if (!isString(fieldName)) {
throw new Error("It looks like you forgot to pass the fieldName to `fieldWithHooks`, we're sorry this is current necessary.");
}
if (!fieldScope) {
throw new Error("All calls to `fieldWithHooks` must specify a `fieldScope` " + "argument that gives additional context about the field so " + "that further plugins may more easily understand the field. " + "Keys within this object should contain the phrase 'field' " + "since they will be merged into the parent objects scope and " + "are not allowed to clash. If you really have no additional " + "information to give, please just pass `{}`.");
}
const argDataGenerators = [];
fieldArgDataGeneratorsByFieldName[fieldName] = argDataGenerators;
let newSpec = spec;
const context = { ...commonContext,
Self,
addDataGenerator(fn) {
return addDataGeneratorForField(fieldName, fn);
},
addArgDataGenerator(fn) {
ensureName(fn);
argDataGenerators.push(fn);
},
getDataFromParsedResolveInfoFragment: (parsedResolveInfoFragment, ReturnType) => {
const Type = getNamedType(ReturnType);
const data = {};
const {
fields,
args
} = this.simplifyParsedResolveInfoFragmentWithType(parsedResolveInfoFragment, ReturnType); // Args -> argDataGenerators
for (let dgIndex = 0, dgCount = argDataGenerators.length; dgIndex < dgCount; dgIndex++) {
const gen = argDataGenerators[dgIndex];
try {
mergeData(data, gen, ReturnType, args);
} catch (e) {
debug("Failed to execute argDataGenerator '%s' on %s of %s", gen.displayName || gen.name || "anonymous", fieldName, getNameFromType(Self));
throw e;
}
} // finalSpec.type -> fieldData
if (!finalSpec) {
throw new Error("It's too early to call this! Call from within resolve");
}
const fieldDataGeneratorsByFieldName = fieldDataGeneratorsByFieldNameByType.get(Type);
if (fieldDataGeneratorsByFieldName && isCompositeType(Type) && !isAbstractType(Type)) {
const typeFields = Type.getFields();
const keys = Object.keys(fields);
for (let keyIndex = 0, keyCount = keys.length; keyIndex < keyCount; keyIndex++) {
const alias = keys[keyIndex];
const field = fields[alias];
const gens = fieldDataGeneratorsByFieldName[field.name];
if (gens) {
const FieldReturnType = typeFields[field.name].type;
for (let i = 0, l = gens.length; i < l; i++) {
mergeData(data, gens[i], FieldReturnType, field);
}
}
}
}
return data;
},
scope: (0, _extend.default)((0, _extend.default)({ ...scope
}, {
fieldName
}, `Within context for GraphQLObjectType '${rawSpec.name}'`), fieldScope, `Extending scope for field '${fieldName}' within context for GraphQLObjectType '${rawSpec.name}'`)
};
if (typeof newSpec === "function") {
newSpec = newSpec(context);
}
newSpec = builder.applyHooks(this, "GraphQLObjectType:fields:field", newSpec, context, `|${getNameFromType(Self)}.fields.${fieldName}`);
newSpec.args = newSpec.args || {};
newSpec = { ...newSpec,
args: builder.applyHooks(this, "GraphQLObjectType:fields:field:args", newSpec.args, { ...context,
field: newSpec,
returnType: newSpec.type
}, `|${getNameFromType(Self)}.fields.${fieldName}`)
};
const finalSpec = newSpec;
processedFields.push(finalSpec);
return finalSpec;
}
};
let rawFields = rawSpec.fields || {};
if (typeof rawFields === "function") {
rawFields = rawFields(fieldsContext);
}
const fieldsSpec = builder.applyHooks(this, "GraphQLObjectType:fields", this.extend({}, rawFields, `Default field included in newWithHooks call for '${rawSpec.name}'. ${inScope.__origin || ""}`), fieldsContext, `|${rawSpec.name}`); // Finally, check through all the fields that they've all been processed; any that have not we should do so now.
for (const fieldName in fieldsSpec) {
const fieldSpec = fieldsSpec[fieldName];
if (processedFields.indexOf(fieldSpec) < 0) {
// We've not processed this yet; process it now!
fieldsSpec[fieldName] = fieldsContext.fieldWithHooks(fieldName, fieldSpec, {
autoField: true // We don't have any additional information
});
}
}
return fieldsSpec;
}
};
} else if (Type === GraphQLInputObjectType) {
const commonContext = {
type: "GraphQLInputObjectType",
scope
};
newSpec = builder.applyHooks(this, "GraphQLInputObjectType", newSpec, commonContext, `|${newSpec.name}`);
newSpec.fields = newSpec.fields || {};
const rawSpec = newSpec;
newSpec = { ...newSpec,
fields: () => {
const processedFields = [];
const fieldsContext = { ...commonContext,
Self,
GraphQLInputObjectType: rawSpec,
fieldWithHooks: (fieldName, spec, fieldScope = {}) => {
if (!isString(fieldName)) {
throw new Error("It looks like you forgot to pass the fieldName to `fieldWithHooks`, we're sorry this is current necessary.");
}
const context = { ...commonContext,
Self,
scope: (0, _extend.default)((0, _extend.default)({ ...scope
}, {
fieldName
}, `Within context for GraphQLInputObjectType '${rawSpec.name}'`), fieldScope, `Extending scope for field '${fieldName}' within context for GraphQLInputObjectType '${rawSpec.name}'`)
};
let newSpec = spec;
if (typeof newSpec === "function") {
newSpec = newSpec(context);
}
newSpec = builder.applyHooks(this, "GraphQLInputObjectType:fields:field", newSpec, context, `|${getNameFromType(Self)}.fields.${fieldName}`);
const finalSpec = newSpec;
processedFields.push(finalSpec);
return finalSpec;
}
};
let rawFields = rawSpec.fields;
if (typeof rawFields === "function") {
rawFields = rawFields(fieldsContext);
}
const fieldsSpec = builder.applyHooks(this, "GraphQLInputObjectType:fields", this.extend({}, rawFields, `Default field included in newWithHooks call for '${rawSpec.name}'. ${inScope.__origin || ""}`), fieldsContext, `|${getNameFromType(Self)}`); // Finally, check through all the fields that they've all been processed; any that have not we should do so now.
for (const fieldName in fieldsSpec) {
const fieldSpec = fieldsSpec[fieldName];
if (processedFields.indexOf(fieldSpec) < 0) {
// We've not processed this yet; process it now!
fieldsSpec[fieldName] = fieldsContext.fieldWithHooks(fieldName, fieldSpec, {
autoField: true // We don't have any additional information
});
}
}
return fieldsSpec;
}
};
} else if (Type === GraphQLEnumType) {
const commonContext = {
type: "GraphQLEnumType",
scope
};
newSpec = builder.applyHooks(this, "GraphQLEnumType", newSpec, commonContext, `|${newSpec.name}`);
newSpec.values = builder.applyHooks(this, "GraphQLEnumType:values", newSpec.values, commonContext, `|${newSpec.name}`);
const values = newSpec.values;
newSpec.values = Object.keys(values).reduce((memo, valueKey) => {
const value = values[valueKey];
const newValue = builder.applyHooks(this, "GraphQLEnumType:values:value", value, commonContext, `|${newSpec.name}|${valueKey}`);
memo[valueKey] = newValue;
return memo;
}, {});
} else if (Type === GraphQLUnionType) {
const commonContext = {
type: "GraphQLUnionType",
scope
};
newSpec = builder.applyHooks(this, "GraphQLUnionType", newSpec, { ...commonContext
}, `|${newSpec.name}`);
const rawSpec = newSpec;
newSpec = { ...newSpec,
types: () => {
const typesContext = { ...commonContext,
Self,
GraphQLUnionType: rawSpec
};
let rawTypes = rawSpec.types || [];
if (typeof rawTypes === "function") {
rawTypes = rawTypes(typesContext);
}
return builder.applyHooks(this, "GraphQLUnionType:types", rawTypes, typesContext, `|${getNameFromType(Self)}`);
}
};
}
const finalSpec = newSpec;
const Self = new Type(finalSpec);
if (!(Self instanceof GraphQLSchema) && performNonEmptyFieldsCheck) {
try {
if (Self instanceof GraphQLInterfaceType || Self instanceof GraphQLObjectType || Self instanceof GraphQLInputObjectType) {
const _Self = Self;
if (typeof _Self.getFields === "function") {
const fields = _Self.getFields();
if (Object.keys(fields).length === 0) {
// We require there's at least one field on GraphQLObjectType and GraphQLInputObjectType records
return null;
}
}
}
} catch (e) {
// This is the error we're expecting to handle:
// https://github.com/graphql/graphql-js/blob/831598ba76f015078ecb6c5c1fbaf133302f3f8e/src/type/definition.js#L526-L531
if (inScope && inScope.isRootQuery) {
throw e;
}
const isProbablyAnEmptyObjectError = !!e.message.match(/function which returns such an object/);
if (!isProbablyAnEmptyObjectError) {
this.swallowError(e);
}
return null;
}
}
this.scopeByType.set(Self, scope);
if (finalSpec.name) {
this.addType(Self, scope.__origin || (this ? `'newWithHooks' call during hook '${this.status.currentHookName}'` : null));
}
fieldDataGeneratorsByFieldNameByType.set(Self, fieldDataGeneratorsByFieldName);
fieldArgDataGeneratorsByFieldNameByType.set(Self, fieldArgDataGeneratorsByFieldName);
return Self;
},
fieldDataGeneratorsByType: fieldDataGeneratorsByFieldNameByType,
// @deprecated
fieldDataGeneratorsByFieldNameByType,
fieldArgDataGeneratorsByFieldNameByType,
inflection: {
pluralize: _pluralize.default,
singularize: _pluralize.default.singular,
upperCamelCase: _utils.upperCamelCase,
camelCase: _utils.camelCase,
constantCase: _utils.constantCase,
// Built-in names (allows you to override these in the output schema)
builtin: name => {
/*
* e.g.:
*
* graphile-build:
*
* - Query
* - Mutation
* - Subscription
* - Node
* - PageInfo
*
* graphile-build-pg:
*
* - Interval
* - BigInt
* - BigFloat
* - BitString
* - Point
* - Date
* - Datetime
* - Time
* - JSON
* - UUID
* - InternetAddress
*
* Other plugins may add their own builtins too; try and avoid conflicts!
*/
return name;
},
// When converting a query field to a subscription (live query) field, this allows you to rename it
live: name => name,
// Try and make something a valid GraphQL 'Name'
coerceToGraphQLName: name => {
let resultingName = name;
/*
* Name is defined in GraphQL to match this regexp:
*
* /^[_A-Za-z][_0-9A-Za-z]*$/
*
* See: https://graphql.github.io/graphql-spec/June2018/#sec-Appendix-Grammar-Summary.Lexical-Tokens
*
* So if our 'name' starts with a digit, we must prefix it with
* something. We'll just use an underscore.
*/
if (resultingName.match(/^[0-9]/)) {
resultingName = "_" + resultingName;
}
/*
* Fields beginning with two underscores are reserved by the GraphQL
* introspection systems, trim to just one.
*/
resultingName = resultingName.replace(/^__+/g, "_");
return resultingName;
}
},
swallowError: _swallowError.default,
// resolveNode: EXPERIMENTAL, API might change!
resolveNode: _resolveNode.default,
status: {
currentHookName: null,
currentHookEvent: null
},
liveCoordinator: new _Live.LiveCoordinator(),
scopeByType: new Map()
};
}
//# sourceMappingURL=makeNewBuild.js.map |
/*
Aman-nexus
Goals:
* Full coin infrastructure test mock
* Gateway between middle earth and aman RPC, mixing of coins
* audibility
*/
require('dotenv').config();
const log = require('@arbiter/dumb-lumberjack')
const TAG = " | app | "
const nexus = require("./modules/nexus-wallet.js")
nexus.initialize()
|
import { cilTrash } from "@coreui/icons";
import CIcon from "@coreui/icons-react";
import {
CAlert,
CCard,
CCardBody,
CCardHeader,
CForm,
CFormGroup,
CInput,
CButton,
CBadge,
} from "@coreui/react";
import React, { useContext, useEffect, useState } from "react";
import getFileBerkasKp from "src/context/actions/DownloadFile/getFileBerkasKp";
import {
deleteBerkasKp,
getBerkasKp,
insertBerkasKp,
} from "src/context/actions/UserPage/BerkasKp";
import { GlobalContext } from "src/context/Provider";
import getFilename from "src/helpers/getFilename";
import Loading from "src/reusable/Loading";
import LoadingSubmit from "src/reusable/LoadingSubmit";
import swal2 from "sweetalert2";
import withReactContent from "sweetalert2-react-content";
const Swal = withReactContent(swal2);
const KenaikanPangkat = () => {
const { berkasKpState, berkasKpDispatch, userState } =
useContext(GlobalContext);
const { data: berkasKp } = berkasKpState;
const { data: user } = userState;
const [loadingUpload, setLoadingUpload] = useState(false);
const [input, setInput] = useState({
error: "",
});
// useEffect(() => {
// console.log(input);
// }, [input]);
// Get Berkas Kenaikan Pangkat
useEffect(() => {
if (user) {
getBerkasKp(user.id_pegawai, berkasKpDispatch);
}
}, [berkasKpDispatch, user]);
// Delete berkas
const handleDeleteBerkas = (id) => {
Swal.fire({
icon: "error",
title: "Anda yakin ingin menghapus data ini ?",
text: "Jika yakin, klik YA",
showConfirmButton: true,
showCancelButton: true,
confirmButtonColor: "#3085d6",
cancelButtonColor: "#d33",
confirmButtonText: "YA",
}).then((res) => {
if (res.isConfirmed) {
deleteBerkasKp(user.id_pegawai, id, berkasKpDispatch, Swal);
}
});
};
const handleChangeUploadFiles = (e) => {
if (e.target.files.length === 0) {
setInput({
...input,
error: "Berkas belum dipilih",
});
} else {
setInput({
...input,
[e.target.name]: e.target.files,
error: "",
});
// setInput({ ...input, [e.target.name]: e.target.files });
// console.log("oke");
}
};
const handleUploadFiles = () => {
const formData = new FormData();
// Validasi
if (!input.berkas) {
// Jika berkas belum dipilih
setInput({
...input,
error: "Berkas belum dipilih",
});
} else if (input.berkas.length === 0) {
// Jika berkas belum dipilih
setInput({
...input,
error: "Berkas belum dipilih",
});
} else {
// Jika berkas sudah ada
setInput({
...input,
error: "",
});
// Proses upload file via API
Array.from(input.berkas).forEach((item, index) => {
formData.append(`berkas_kp[${index}]`, item);
});
insertBerkasKp(
user.id_pegawai,
formData,
berkasKpDispatch,
setLoadingUpload,
Swal
);
}
};
return (
<div>
<CCard>
<CCardHeader>
<h3>Kenaikan Pangkat</h3>
</CCardHeader>
<CCardBody>
{!berkasKp ? (
<Loading />
) : (
<>
<CAlert color="info" closeButton fade>
Silahkan upload berkas sesuai dengan persyaratan dan jenis
kenaikan pangkat (Reguler, Jabatan Struktural, Jabatan
Fungsional)
</CAlert>
<CForm className="mb-4">
<CFormGroup
className="d-flex"
style={{ width: "400px", marginBottom: 0 }}
>
<CInput
type="file"
name="berkas"
multiple
onChange={(e) => handleChangeUploadFiles(e)}
className={input.error ? "is-invalid" : null}
/>
<CButton
color="primary"
className="ml-2"
onClick={handleUploadFiles}
disabled={loadingUpload ? true : false}
>
{loadingUpload ? <LoadingSubmit /> : "Upload"}
</CButton>
</CFormGroup>
{input.error && (
<div className="text-danger">{input.error}</div>
)}
</CForm>
{/* Jika sudah berkas yang diupload maka tampilkan indikator status validasi */}
{berkasKp.berkas_kp.length > 0 && (
<>
{/* Status Belum Tervalidasi */}
{berkasKp.kenaikan_pangkat.status_validasi === 0 && (
<table className="table table-bordered">
<tbody>
<tr>
<th>Status</th>
<td>
<CBadge color="danger">
Menunggu persetujuan admin
</CBadge>
</td>
</tr>
</tbody>
</table>
)}
{/* Status Sudah Tervalidasi */}
{berkasKp.kenaikan_pangkat.status_validasi === 1 && (
<table className="table table-bordered">
<tbody>
<tr>
<th>Status</th>
<td>
<CBadge color="success">
Berkas Anda telah disetujui
</CBadge>
</td>
</tr>
</tbody>
</table>
)}
{/* Status Tidak Disetujui */}
{berkasKp.kenaikan_pangkat.status_validasi === 2 && (
<table className="table table-bordered">
<tbody>
<tr>
<th>Status</th>
<td>
<CBadge color="danger">
Berkas Anda belum disetujui
</CBadge>
</td>
</tr>
<tr>
<th>Keterangan</th>
<td>
{berkasKp.kenaikan_pangkat.ket_status_validasi}
</td>
</tr>
</tbody>
</table>
)}
</>
)}
{/* Tabel upload file */}
<table className="table">
<thead>
<tr>
<th>No</th>
<th>Berkas</th>
<th>Aksi</th>
</tr>
</thead>
<tbody>
{berkasKp.berkas_kp.map((item, index) => (
<>
<tr key={index}>
<td width={80}>{index + 1}</td>
<td>
<a
href={getFileBerkasKp(item.file)}
target="_blank"
rel="noreferrer"
>
{getFilename(item.file)}
</a>
</td>
<td>
<CButton
color="danger"
onClick={() =>
handleDeleteBerkas(item.id_berkas_kp)
}
>
<CIcon content={cilTrash} />
</CButton>
</td>
</tr>
</>
))}
</tbody>
</table>
</>
)}
</CCardBody>
</CCard>
</div>
);
};
export default KenaikanPangkat;
|
from django.shortcuts import render, render_to_response, get_object_or_404
from django.views.generic.detail import View
from django.views.generic.edit import FormView
from django.conf import settings
from comparedata.forms import JobForm
from comparedata.models import Job, Org, Object, ObjectField, UnmatchedRecord
from django.http import HttpResponse, HttpResponseRedirect
from comparedata.tasks import get_objects_task, compare_data_task
import sys
import datetime
import uuid
import requests
import json
import ast
reload(sys)
sys.setdefaultencoding("utf-8")
class IndexView(FormView):
"""
Home Page Controller
"""
template_name = 'index.html'
form_class = JobForm
# When view is called via GET
def get(self, request, *args, **kwargs):
return render(request, self.template_name, {
'client_id': settings.SALESFORCE_CONSUMER_KEY,
'redirect_uri': settings.SALESFORCE_REDIRECT_URI
})
# Valid form posting
def form_valid(self, form):
# Create the job record
job = Job()
job.random_id = uuid.uuid4()
job.created_date = datetime.datetime.now()
job.status = 'Not Started'
job.save()
# Create org one record
org_one = Org.objects.get(pk = form.cleaned_data['org_one'])
org_one.job = job
org_one.save()
# Create org two record
org_two = Org.objects.get(pk = form.cleaned_data['org_two'])
org_two.job = job
org_two.save()
return HttpResponseRedirect('/loading/' + str(job.random_id))
class OAuthResponse(View):
"""
OAuth Response Controller
"""
template_name = 'oauth_response.html'
# When view is called via GET
def get(self, request, *args, **kwargs):
oauth_code = request.GET.get('code')
environment = request.GET.get('state')[:-4]
org_choice = request.GET.get('state')[-4:]
access_token = ''
instance_url = ''
org_id = ''
error_exists = False
error_message = ''
username = ''
email = ''
org_name = ''
org = Org()
if 'Production' in environment:
login_url = 'https://login.salesforce.com'
else:
login_url = 'https://test.salesforce.com'
r = requests.post(
login_url + '/services/oauth2/token',
headers={
'content-type':'application/x-www-form-urlencoded'
},
data={
'grant_type':'authorization_code',
'client_id': settings.SALESFORCE_CONSUMER_KEY,
'client_secret': settings.SALESFORCE_CONSUMER_SECRET,
'redirect_uri': settings.SALESFORCE_REDIRECT_URI,
'code': oauth_code
}
)
auth_response = json.loads(r.text)
if 'error_description' in auth_response:
error_exists = True
error_message = auth_response['error_description']
else:
access_token = auth_response['access_token']
instance_url = auth_response['instance_url']
user_id = auth_response['id'][-18:]
org_id = auth_response['id'][:-19]
org_id = org_id[-18:]
# get username of the authenticated user
r = requests.get(
instance_url + '/services/data/v' + str(settings.SALESFORCE_API_VERSION) + '.0/sobjects/User/' + user_id + '?fields=Username,Email',
headers={
'Authorization': 'OAuth ' + access_token
}
)
if 'errorCode' in r.text:
error_exists = True
error_message = r.json()[0]['message']
else:
username = r.json()['Username']
email = r.json()['Email']
# get the org name of the authenticated user
r = requests.get(
instance_url + '/services/data/v' + str(settings.SALESFORCE_API_VERSION) + '.0/sobjects/Organization/' + org_id + '?fields=Name',
headers={
'Authorization': 'OAuth ' + access_token
}
)
if 'errorCode' in r.text:
error_exists = True
error_message = r.json()[0]['message']
else:
org_name = r.json()['Name']
org = Org()
org.access_token = access_token
org.instance_url = instance_url
org.org_id = org_id
org.org_name = org_name
org.username = username
if org_choice == 'org1':
org.org_number = 1
else:
org.org_number = 2
org.save()
return render(request, self.template_name, {
'client_id': settings.SALESFORCE_CONSUMER_KEY,
'redirect_uri': settings.SALESFORCE_REDIRECT_URI,
'error': error_exists,
'error_message': error_message,
'username': username,
'org_name': org_name,
'org_choice': org_choice,
'org': org,
'email': email,
'instance_url': instance_url
})
class LoadingPage(View):
"""
Generic loading page for async jobs
"""
template_name = 'loading.html'
# When view is called via GET
def get(self, request, *args, **kwargs):
job = get_object_or_404(Job, random_id = self.kwargs['job_id'])
if job.status == 'Not Started':
job.status = 'Start Object Download'
job.save()
# Begin download of objects and fields
get_objects_task.delay(job)
elif job.status == 'Objects Downloaded':
return HttpResponseRedirect('/select-object/' + str(job.random_id) + '/')
elif job.status == 'Finished':
return HttpResponseRedirect('/compare-data-result/' + str(job.random_id) + '/')
return render(request, self.template_name, {
'job': job
})
class SelectObject(View):
"""
Select Object Controller
"""
template_name = 'select_object.html'
# When view is called via GET
def get(self, request, *args, **kwargs):
job = get_object_or_404(Job, random_id = self.kwargs['job_id'])
return render(request, self.template_name, {
'job': job
})
class CompareDataResult(View):
"""
The compare data result controller
"""
template_name = 'compare_data_result.html'
# When view is called via GET
def get(self, request, *args, **kwargs):
job = get_object_or_404(Job, random_id = self.kwargs['job_id'])
return render(request, self.template_name, {
'job': job
})
# AJAX endpoint for page to constantly check if job is finished
def job_status(request, job_id):
# Query for the job record
job = get_object_or_404(Job, random_id = job_id)
response_data = {
'status': job.status,
'error': job.error
}
return HttpResponse(json.dumps(response_data), content_type = 'application/json')
# Endpoint called from AJAX to trigger field query for an object
def get_fields(request, job_id, object_id):
# Query for the job record
job = get_object_or_404(Job, random_id = job_id)
object = get_object_or_404(Object, pk = object_id)
# If the fields already exist
if object.sorted_fields():
# Field list
fields = []
# Iterate over the stored fields
for field in object.sorted_fields():
# Append to return list
fields.append({
'id': field.id,
'label': field.label,
'api_name': field.api_name,
'type': field.type
})
# Return the list of fields to the page
return HttpResponse(json.dumps(fields), content_type = 'application/json')
# Otherwise, need to query for them via api
else:
# List of fields to query
field_list = []
# The orgs used for querying
org_one = job.sorted_orgs()[0]
org_two = job.sorted_orgs()[1]
try:
# Query for Org One fields
org_one_fields = requests.get(
org_one.instance_url + '/services/data/v' + str(settings.SALESFORCE_API_VERSION) + '.0/sobjects/' + object.api_name + '/describe/',
headers={
'Authorization': 'Bearer ' + org_one.access_token,
'content-type': 'application/json'
}
)
# If there was an error with the request
if org_one_fields.status_code != 200:
# Set response data for page
response_data = {
'error': True,
'errorMessage': 'Error querying fields for Org One\n\n' + org_one_fields.json()[0]['errorCode'] + ': ' + org_one_fields.json()[0]['message']
}
return HttpResponse(json.dumps(response_data), content_type = 'application/json')
# Loop through the org one fields
for field in org_one_fields.json()['fields']:
field_list.append(field['name'])
# Query for Org 2 fields
org_two_fields = requests.get(
org_two.instance_url + '/services/data/v' + str(settings.SALESFORCE_API_VERSION) + '.0/sobjects/' + object.api_name + '/describe/',
headers={
'Authorization': 'Bearer ' + org_two.access_token,
'content-type': 'application/json'
}
)
# If there was an error with the request
if org_two_fields.status_code != 200:
# Set response data for page
response_data = {
'error': True,
'errorMessage': 'Error querying fields for Org One\n\n' + org_two_fields.json()[0]['errorCode'] + ': ' + org_two_fields.json()[0]['message']
}
return HttpResponse(json.dumps(response_data), content_type = 'application/json')
# Field list
fields = []
# Loop through the org twp fields
for field in org_two_fields.json()['fields']:
# If the field exists in the set
if field['name'] in field_list:
# Create field
new_field = ObjectField()
new_field.object = object
new_field.api_name = field['name']
new_field.label = field['label']
# Determine the field type
# If a formula field, set to formula and add the return type in brackets
if 'calculated' in field and (field['calculated'] == True or field['calculated'] == 'true'):
new_field.type = 'Formula (' + field['type'].title() + ')'
# lookup field
elif field['type'] == 'reference':
new_field.type = 'Lookup ('
# Could be a list of reference objects
for referenceObject in field['referenceTo']:
new_field.type = new_field.type + referenceObject.title() + ', '
# remove trailing comma and add closing bracket
new_field.type = new_field.type[:-2]
new_field.type = new_field.type + ')'
else:
new_field.type = field['type'].title()
new_field.save()
# Re-query fields to sort alphabetically
for field in ObjectField.objects.filter(object = object).order_by('label'):
# Append to return list
fields.append({
'id': field.id,
'label': field.label,
'api_name': field.api_name,
'type': field.type
})
# Return the list of fields to the page
return HttpResponse(json.dumps(fields), content_type = 'application/json')
except:
# Set response data for page
response_data = {
'error': True,
'errorMessage': traceback.format_exc()
}
return HttpResponse(json.dumps(response_data), content_type = 'application/json')
# AJAX endpoint to execute the data compare job
def execute_data_compare(request, job_id, object_id):
# Query for the job and object
job = get_object_or_404(Job, random_id = job_id)
object = get_object_or_404(Object, pk = object_id)
# If POST request made
if request.method == 'POST':
# Parse POST data into array
fields = json.loads(request.body)
else:
# Get the fields from the job
fields = job.fields.split(',')
# Update the status
job.status = 'Begin Data Compare'
job.save()
# Delete existing unmatched records
job.unmatched_records().delete()
# Execute the job
compare_data_task.delay(job, object, fields)
# Return the URL to the page
return HttpResponse('/loading/' + str(job.random_id) + '/')
# AJAX endpoint to get unmatched rows for a job and org
def get_unmatched_rows(request, job_id, org_no):
# Query for the job and object
job = get_object_or_404(Job, random_id = job_id)
# List of records to return
unmatched_records = []
# Iterate over data
for record in job.sorted_orgs()[int(org_no)].unmatched_records().values_list('data', flat=True):
# Convert to JSON
unmatched_records.append(json.loads(record))
# Return records to page
return HttpResponse(json.dumps(unmatched_records), content_type = 'application/json')
|
# 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 . import outputs
__all__ = [
'GetClusterResult',
'AwaitableGetClusterResult',
'get_cluster',
]
@pulumi.output_type
class GetClusterResult:
"""
Class representing a Kusto cluster.
"""
def __init__(__self__, data_ingestion_uri=None, enable_disk_encryption=None, enable_streaming_ingest=None, id=None, location=None, name=None, optimized_autoscale=None, provisioning_state=None, sku=None, state=None, tags=None, trusted_external_tenants=None, type=None, uri=None, virtual_network_configuration=None, zones=None):
if data_ingestion_uri and not isinstance(data_ingestion_uri, str):
raise TypeError("Expected argument 'data_ingestion_uri' to be a str")
pulumi.set(__self__, "data_ingestion_uri", data_ingestion_uri)
if enable_disk_encryption and not isinstance(enable_disk_encryption, bool):
raise TypeError("Expected argument 'enable_disk_encryption' to be a bool")
pulumi.set(__self__, "enable_disk_encryption", enable_disk_encryption)
if enable_streaming_ingest and not isinstance(enable_streaming_ingest, bool):
raise TypeError("Expected argument 'enable_streaming_ingest' to be a bool")
pulumi.set(__self__, "enable_streaming_ingest", enable_streaming_ingest)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if location and not isinstance(location, str):
raise TypeError("Expected argument 'location' to be a str")
pulumi.set(__self__, "location", location)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if optimized_autoscale and not isinstance(optimized_autoscale, dict):
raise TypeError("Expected argument 'optimized_autoscale' to be a dict")
pulumi.set(__self__, "optimized_autoscale", optimized_autoscale)
if provisioning_state and not isinstance(provisioning_state, str):
raise TypeError("Expected argument 'provisioning_state' to be a str")
pulumi.set(__self__, "provisioning_state", provisioning_state)
if sku and not isinstance(sku, dict):
raise TypeError("Expected argument 'sku' to be a dict")
pulumi.set(__self__, "sku", sku)
if state and not isinstance(state, str):
raise TypeError("Expected argument 'state' to be a str")
pulumi.set(__self__, "state", state)
if tags and not isinstance(tags, dict):
raise TypeError("Expected argument 'tags' to be a dict")
pulumi.set(__self__, "tags", tags)
if trusted_external_tenants and not isinstance(trusted_external_tenants, list):
raise TypeError("Expected argument 'trusted_external_tenants' to be a list")
pulumi.set(__self__, "trusted_external_tenants", trusted_external_tenants)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
if uri and not isinstance(uri, str):
raise TypeError("Expected argument 'uri' to be a str")
pulumi.set(__self__, "uri", uri)
if virtual_network_configuration and not isinstance(virtual_network_configuration, dict):
raise TypeError("Expected argument 'virtual_network_configuration' to be a dict")
pulumi.set(__self__, "virtual_network_configuration", virtual_network_configuration)
if zones and not isinstance(zones, list):
raise TypeError("Expected argument 'zones' to be a list")
pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="dataIngestionUri")
def data_ingestion_uri(self) -> str:
"""
The cluster data ingestion URI.
"""
return pulumi.get(self, "data_ingestion_uri")
@property
@pulumi.getter(name="enableDiskEncryption")
def enable_disk_encryption(self) -> Optional[bool]:
"""
A boolean value that indicates if the cluster's disks are encrypted.
"""
return pulumi.get(self, "enable_disk_encryption")
@property
@pulumi.getter(name="enableStreamingIngest")
def enable_streaming_ingest(self) -> Optional[bool]:
"""
A boolean value that indicates if the streaming ingest is enabled.
"""
return pulumi.get(self, "enable_streaming_ingest")
@property
@pulumi.getter
def id(self) -> str:
"""
Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
"""
return pulumi.get(self, "id")
@property
@pulumi.getter
def location(self) -> str:
"""
The geo-location where the resource lives
"""
return pulumi.get(self, "location")
@property
@pulumi.getter
def name(self) -> str:
"""
The name of the resource
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="optimizedAutoscale")
def optimized_autoscale(self) -> Optional['outputs.OptimizedAutoscaleResponse']:
"""
Optimized auto scale definition.
"""
return pulumi.get(self, "optimized_autoscale")
@property
@pulumi.getter(name="provisioningState")
def provisioning_state(self) -> str:
"""
The provisioned state of the resource.
"""
return pulumi.get(self, "provisioning_state")
@property
@pulumi.getter
def sku(self) -> 'outputs.AzureSkuResponse':
"""
The SKU of the cluster.
"""
return pulumi.get(self, "sku")
@property
@pulumi.getter
def state(self) -> str:
"""
The state of the resource.
"""
return pulumi.get(self, "state")
@property
@pulumi.getter
def tags(self) -> Optional[Mapping[str, str]]:
"""
Resource tags.
"""
return pulumi.get(self, "tags")
@property
@pulumi.getter(name="trustedExternalTenants")
def trusted_external_tenants(self) -> Optional[Sequence['outputs.TrustedExternalTenantResponse']]:
"""
The cluster's external tenants.
"""
return pulumi.get(self, "trusted_external_tenants")
@property
@pulumi.getter
def type(self) -> str:
"""
The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
"""
return pulumi.get(self, "type")
@property
@pulumi.getter
def uri(self) -> str:
"""
The cluster URI.
"""
return pulumi.get(self, "uri")
@property
@pulumi.getter(name="virtualNetworkConfiguration")
def virtual_network_configuration(self) -> Optional['outputs.VirtualNetworkConfigurationResponse']:
"""
Virtual network definition.
"""
return pulumi.get(self, "virtual_network_configuration")
@property
@pulumi.getter
def zones(self) -> Optional[Sequence[str]]:
"""
The availability zones of the cluster.
"""
return pulumi.get(self, "zones")
class AwaitableGetClusterResult(GetClusterResult):
# pylint: disable=using-constant-test
def __await__(self):
if False:
yield self
return GetClusterResult(
data_ingestion_uri=self.data_ingestion_uri,
enable_disk_encryption=self.enable_disk_encryption,
enable_streaming_ingest=self.enable_streaming_ingest,
id=self.id,
location=self.location,
name=self.name,
optimized_autoscale=self.optimized_autoscale,
provisioning_state=self.provisioning_state,
sku=self.sku,
state=self.state,
tags=self.tags,
trusted_external_tenants=self.trusted_external_tenants,
type=self.type,
uri=self.uri,
virtual_network_configuration=self.virtual_network_configuration,
zones=self.zones)
def get_cluster(cluster_name: Optional[str] = None,
resource_group_name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetClusterResult:
"""
Class representing a Kusto cluster.
:param str cluster_name: The name of the Kusto cluster.
:param str resource_group_name: The name of the resource group containing the Kusto cluster.
"""
__args__ = dict()
__args__['clusterName'] = cluster_name
__args__['resourceGroupName'] = resource_group_name
if opts is None:
opts = pulumi.InvokeOptions()
if opts.version is None:
opts.version = _utilities.get_version()
__ret__ = pulumi.runtime.invoke('azure-native:kusto/v20190515:getCluster', __args__, opts=opts, typ=GetClusterResult).value
return AwaitableGetClusterResult(
data_ingestion_uri=__ret__.data_ingestion_uri,
enable_disk_encryption=__ret__.enable_disk_encryption,
enable_streaming_ingest=__ret__.enable_streaming_ingest,
id=__ret__.id,
location=__ret__.location,
name=__ret__.name,
optimized_autoscale=__ret__.optimized_autoscale,
provisioning_state=__ret__.provisioning_state,
sku=__ret__.sku,
state=__ret__.state,
tags=__ret__.tags,
trusted_external_tenants=__ret__.trusted_external_tenants,
type=__ret__.type,
uri=__ret__.uri,
virtual_network_configuration=__ret__.virtual_network_configuration,
zones=__ret__.zones)
|
#! /usr/bin/env python3
import logging
from typing import cast
from core.app import App
from player_ui import PlayerUI
logger = logging.getLogger('player')
class PlayerApp(App):
def setup(self):
self.ui = PlayerUI(self)
self.injector.provide(PlayerUI, lambda: self.ui)
@classmethod
def get_instance(cls) -> 'PlayerApp':
return cast(PlayerApp, cls._instance)
if __name__ == '__main__':
PlayerApp().run_forever()
|
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Architecture import *
from Autodesk.Revit.DB.Analysis import *
from Autodesk.Revit.DB.Plumbing import *
from Autodesk.Revit.Exceptions import *
from Autodesk.Revit.UI import TaskDialog
from Autodesk.Revit.UI import TaskDialogCommonButtons
from Autodesk.Revit.UI import TaskDialogResult
import ctypes
#Load CoolProp shared library and configure PropsSI c_types units
CP = ctypes.cdll.LoadLibrary(r"C:\Program Files (x86)\pythoncvc.net\RevitPyCVC\Fluides\dll\CoolProp.dll")
PropsSI = CP.PropsSI
PropsSI.argtypes = (ctypes.c_char_p, ctypes.c_char_p, ctypes.c_double, ctypes.c_char_p, ctypes.c_double, ctypes.c_char_p)
PropsSI.restype = ctypes.c_double
uidoc = __revit__.ActiveUIDocument
doc = __revit__.ActiveUIDocument.Document
#Set desired fluid, initial temperature(freezing temperature ?), desired pressure for properties call
fluid = 'Water'
t_init = 273.15
pressure = 101325
#Check if fluid_type exist and create it if not
fluid_type = FluidType.GetFluidType(doc, fluid)
if fluid_type == None:
t = Transaction(doc, "Create fluid type")
t.Start()
FluidType.Create(doc, fluid)
t.Commit()
fluid_type = FluidType.GetFluidType(doc, fluid)
#Add new temperature with associated heat capacity and viscosity
t = Transaction(doc, "Add temperature")
t.Start()
for i in xrange(1,100):
#Call CoolProp to get fluid properties and convert it to internal units if necessary
temperature = 273.15+i
viscosity = UnitUtils.ConvertToInternalUnits(PropsSI('V','T',t_init+i,'P',pressure,fluid),DisplayUnitType.DUT_PASCAL_SECONDS)
density = UnitUtils.ConvertToInternalUnits(PropsSI('D','T',t_init+i,'P',pressure,fluid),DisplayUnitType.DUT_KILOGRAMS_PER_CUBIC_METER)
#Catching exceptions and trying to overwrite temperature if asked by user in the TaskDialog
try:
fluid_type.AddTemperature(FluidTemperature(temperature,viscosity,density))
except ArgumentException:
result = TaskDialog.Show("Error", "Temperature already exist, do you want to overwrite it ?",TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No | TaskDialogCommonButtons.Cancel, TaskDialogResult.Yes)
if result == TaskDialogResult.Yes:
try:
fluid_type.RemoveTemperature(temperature)
fluid_type.AddTemperature(FluidTemperature(temperature,viscosity,density))
except ArgumentException:
TaskDialog.Show("Overwrite error", "Temperature is currently in use and cannot be overwritten")
elif result == TaskDialogResult.No:
pass
else:
break
t.Commit()
|
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
var babylon = require('babylon');
var fs = require('fs');
var options = {
sourceType: 'module',
strictMode: false,
locations: true,
ranges: true,
ecmaVersion: 7,
features: {
'es7.classProperties': true,
'es7.decorators': true,
'es7.comprehensions': true,
'es7.asyncFunctions': true,
'es7.exportExtensions': true,
'es7.trailingFunctionCommas': true,
'es7.objectRestSpread': true,
'es7.doExpressions': true,
'es7.functionBind': true,
},
plugins: { jsx: true, flow: true },
};
export default function parse(src) {
var file = babylon.parse(src, options);
file.program.comments = file.comments;
return file.program;
}
|
import pytest
import tensorflow as tf
import numpy as np
from numpy.testing import assert_array_equal
from model.encdec import BasicEncoder, BasicDecoder, BasicEncoderDecoder, GraphEncoder, GraphDecoder, GraphEncoderDecoder
from model.word_embedder import WordEmbedder
class TestEncoderDecoder(object):
rnn_size = 3
batch_size = 2
seq_len = 4
input_size = 5
num_symbols = 5
vocab_size = 5
word_embed_size = 4
pad = 0
@pytest.fixture(scope='session')
def basic_encoder(self):
return BasicEncoder(self.rnn_size, batch_size=self.batch_size)
@pytest.fixture(scope='session')
def basic_input_dict(self):
input_dict = {'inputs': tf.constant(np.random.randint(self.vocab_size, size=(self.batch_size, self.seq_len)), dtype=tf.int32)}
return input_dict
@pytest.fixture(scope='session')
def last_inds(self):
return np.full([self.batch_size], 2, dtype=np.int32)
def test_basic_encoder(self, basic_encoder, word_embedder, basic_input_dict, last_inds):
output_dict = basic_encoder.build_model(basic_input_dict, word_embedder, time_major=False)
outputs, final_state = output_dict['outputs'], output_dict['final_state']
feed_dict = {basic_encoder.last_inds: last_inds}
with tf.Session() as sess:
tf.initialize_all_variables().run()
[outputs, final_state] = sess.run([outputs, final_state], feed_dict=feed_dict)
assert outputs.shape == (self.seq_len, self.batch_size, self.rnn_size)
@pytest.fixture(scope='session')
def basic_decoder(self):
return BasicDecoder(self.rnn_size, self.num_symbols, batch_size=self.batch_size)
def test_basic_decoder(self, basic_decoder, word_embedder, basic_input_dict, last_inds):
output_dict = basic_decoder.build_model(basic_input_dict, word_embedder, time_major=False)
logits, final_state = output_dict['logits'], output_dict['final_state']
feed_dict = {basic_decoder.last_inds: last_inds}
with tf.Session() as sess:
tf.initialize_all_variables().run()
[logits] = sess.run([logits], feed_dict=feed_dict)
assert logits.shape == (self.batch_size, self.seq_len, self.num_symbols)
@pytest.fixture(scope='session')
def word_embedder(self):
return WordEmbedder(self.vocab_size, self.word_embed_size)
@pytest.fixture(scope='session')
def basic_encoderdecoder(self, word_embedder, basic_encoder, basic_decoder):
return BasicEncoderDecoder(word_embedder, basic_encoder, basic_decoder, self.pad)
@pytest.fixture(scope='session')
def word_seq(self):
return np.array([[0,1,2],
[2,1,3]])
@pytest.fixture(scope='session')
def graph_encoder(self, graph_embedder):
return GraphEncoder(self.rnn_size, graph_embedder, batch_size=self.batch_size)
@pytest.fixture(scope='session')
def graph_decoder(self, graph_embedder):
return GraphDecoder(self.rnn_size, self.num_symbols, graph_embedder, batch_size=self.batch_size)
@pytest.fixture(scope='session')
def graph_encoderdecoder(self, word_embedder, graph_embedder, graph_encoder, graph_decoder):
return GraphEncoderDecoder(word_embedder, graph_embedder, graph_encoder, graph_decoder, self.pad)
def test_graph_encoderdecoder(self, graph_encoderdecoder, graph_batch, tokens, word_seq, last_inds):
with tf.Session() as sess:
tf.initialize_all_variables().run()
graph_data = graph_batch.get_batch_data(tokens, tokens, None)
feed_dict = graph_encoderdecoder.update_feed_dict(encoder_inputs=word_seq, decoder_inputs=word_seq, targets=word_seq, encoder_inputs_last_inds=last_inds, decoder_inputs_last_inds=last_inds)
feed_dict = graph_encoderdecoder.update_feed_dict(feed_dict=feed_dict,
encoder_entities=graph_data['encoder_entities'],
decoder_entities=graph_data['decoder_entities'],
encoder_input_utterances=graph_data['utterances'],
graph_structure=(graph_data['node_ids'], graph_data['entity_ids'], graph_data['paths'], graph_data['node_paths'], graph_data['node_feats']))
[decoder_final_state, loss] = sess.run([graph_encoderdecoder.decoder_final_state, graph_encoderdecoder.loss], feed_dict=feed_dict)
def test_basic_encoderdecoder(self, basic_encoderdecoder, basic_encoder, word_seq, last_inds):
with tf.Session() as sess:
tf.initialize_all_variables().run()
feed_dict = basic_encoderdecoder.update_feed_dict(encoder_inputs=word_seq, decoder_inputs=word_seq, targets=word_seq, encoder_inputs_last_inds=last_inds, decoder_inputs_last_inds=last_inds)
[decoder_final_state, loss] = sess.run([basic_encoderdecoder.decoder_final_state, basic_encoderdecoder.loss], feed_dict=feed_dict)
# Test given encoder_init_state
feed_dict = basic_encoderdecoder.update_feed_dict(encoder_init_state=decoder_final_state, encoder_inputs=word_seq)
[encoder_init_state] = sess.run([basic_encoder.init_state], feed_dict=feed_dict)
assert_array_equal(encoder_init_state, decoder_final_state)
def test_loss_mask(self, basic_encoderdecoder, capsys):
logits = tf.constant(np.ones([2,4,5]), dtype=tf.float32)
targets = tf.constant(np.ones([2,4]) * self.pad, dtype=tf.int32)
loss = basic_encoderdecoder.compute_loss(logits, targets)
with tf.Session() as sess:
tf.initialize_all_variables().run()
[loss] = sess.run([loss])
assert loss == 0
@pytest.fixture(scope='session')
def batch(self, word_seq, last_inds, tokens):
return {'encoder_inputs': word_seq,
'decoder_inputs': word_seq,
'encoder_tokens': tokens,
'decoder_tokens': tokens,
'encoder_inputs_last_inds': last_inds,
'decoder_inputs_last_inds': last_inds,
}
def test_basic_generate(self, basic_encoderdecoder, batch, capsys):
with tf.Session() as sess:
tf.initialize_all_variables().run()
preds, final_state, true_final_state, _ = basic_encoderdecoder.generate(sess, batch, None, 10)
assert preds.shape == (2, 10)
with capsys.disabled():
print '\npreds:\n', preds
print 'final state:\n', final_state
print 'true final state:\n', true_final_state
@pytest.mark.only
def test_graph_generate(self, batch, graph_batch, graph_encoderdecoder, capsys):
with tf.Session() as sess:
tf.initialize_all_variables().run()
preds, final_state, true_final_state, utterances = graph_encoderdecoder.generate(sess, batch, None, 10, graphs=graph_batch)
with capsys.disabled():
print 'utterances:', utterances
|
# 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 oslo_config import cfg
from oslo_log import log
from oslo_service import service
from oslo_service import wsgi
from ironic_inspector import main
LOG = log.getLogger(__name__)
CONF = cfg.CONF
class WSGIService(service.Service):
"""Provides ability to launch API from wsgi app."""
def __init__(self):
self.app = main.get_app()
self.server = wsgi.Server(CONF, 'ironic_inspector',
self.app,
host=CONF.listen_address,
port=CONF.listen_port,
use_ssl=CONF.use_ssl)
def start(self):
"""Start serving this service using loaded configuration.
:returns: None
"""
self.server.start()
def stop(self):
"""Stop serving this API.
:returns: None
"""
self.server.stop()
def wait(self):
"""Wait for the service to stop serving this API.
:returns: None
"""
self.server.wait()
def reset(self):
"""Reset server greenpool size to default.
:returns: None
"""
self.server.reset()
|
/*
This file parses the json from:
https://raw.githubusercontent.com/benetech/math-speech-rule-editor/master/examples/rules.json
https://github.com/benetech/math-speech-rule-editor/blob/master/lib/mathspeak.json
And does part of what is needed to then dynamically generate a .js file like this one:
https://github.com/zorkow/speech-rule-engine/blob/master/src/speech_rules/mathspeak_rules.js
Specifically, to generate the defineRules calls in there.
This is needed, because there are constraints that as the framework currently is, the rules must
be ran from JavaScript in the browser of the user. Otherwise we could have just parsed the json
directly and use the object directly.
The functions in this file need to be integrated in the views and controllers instead. So they
need to be moved.
*/
/**
* Converts JSON format of a single mathspeak rule in json, to the parameters
* for defineRule.
* @param {Object} json The json object.
* @return {Array.<string>} array of strings to give to the defineRule function:
* [name, dynamic, action, query, cstr...]
* Where cstr is constraints, query is selector. There may be multiple
* constraints.
*/
function convertRuleToDefine(o) {
if (!o.key) throw 'must have key (name)';
if (!o.dynamic) throw 'must have dynamic';
if (!o.selector) throw 'must have selector (query)';
var name = o.key;
var dynamic = o.dynamic;
var query = o.selector;
var action = undefined;
var actions = o.actions;
if (actions) {
action = '';
for (var i = 0; i < actions.length; i++) {
if (i > 0) action += '; ';
var a = actions[i];
if (a.type == 'TEXT') action += '[t] ';
else if (a.type == 'NODE') action += '[n] ';
else if (a.type == 'MULTI') action += '[m] ';
else if (a.type == 'PERSONALITY') action += '[p] ';
else throw 'unknown action type';
if (a.content) action += a.content;
if (a.personality && a.personality.length) {
action += ' (';
var p = a.personality;
for (var j = 0; j < p.length; j++) {
if (p[j].length != 2) {
throw 'personality pair must have exactly 2 elements';
}
if (j > 0) action += ', ';
action += p[j][0] + ':' + p[j][1];
}
action += ')';
}
}
}
var result = [name, dynamic, action, query];
if (o.constraints && o.constraints.length) {
var c = o.constraints;
for (var i = 0; i < c.length; i++) {
result.push(c[i]);
}
}
return result;
}
/**
* Converts array of rules objects to array of parameters for defineRules.
* See documentation of convertRuleToDefine.
* @param {Object} o The parsed json object.
* @return {Array.<Array.<string>>}
*/
function convertParsedJsonToRules(o) {
var result = [];
for (var i = 0; i < o.length; i++) {
result.push(convertRuleToDefine(o[i]));
}
return result;
}
/**
* @param {Array.<Array.<string>> The result from convertParsedJsonToRules.
* @return {string} a string containing JS code performing defineRule calls.
*/
function convertParametersToDefineRuleCalls(params) {
if (params[0].length == undefined) params = [params];
var result = '';
for (var i = 0; i < params.length; i++) {
result += 'defineRule(';
var current = params[i];
for (var j = 0; j < current.length; j++) {
if (j > 0) result += ',\n ';
result += '\'' + current[j] + '\'';
}
result += ');\n';
}
return result;
}
/**
* Does everything in one go: converts JSON string to string of defineRule
* function calls.
* See documentation of convertRuleToDefine and
* convertParametersToDefineRuleCalls.
* @param {string} json The json string.
* @return {string}
*/
function convertAllFromJson(json) {
// If not given as array, turn it into one, so that the format becomes the
// expected "[{rules},{rules},...]"
if (json[0] != '[') json = '[' + json + ']';
return convertParametersToDefineRuleCalls(
convertParsedJsonToRules(JSON.parse(json)));
}
|
// All material copyright ESRI, All Rights Reserved, unless otherwise specified.
// See https://js.arcgis.com/4.10/esri/copyright.txt for details.
//>>built
define({widgetLabel:"Tra\u0165",startTracking:"Spustit sledov\u00e1n\u00ed m\u00e9 polohy",stopTracking:"Zastavit sledov\u00e1n\u00ed m\u00e9 polohy"}); |
import Vue from 'vue'
Vue.use({
install(Vue) {
const $window = Vue.observable({
width: 0,
height: 0,
isMobile: true
})
let queue = null
const wait = 100
const getWindowSize = () => {
clearTimeout(queue)
queue = setTimeout(function() {
const width = document.documentElement.clientWidth
$window.width = width
$window.height = document.documentElement.clientHeight
$window.isMobile = width < 768
}, wait)
}
global.addEventListener('resize', getWindowSize)
getWindowSize()
Vue.prototype.$window = $window
}
})
|
import React, { PropTypes, Component } from 'react';
import { connect } from 'react-redux';
import * as actions from './../actions';
import * as storage from './../persistence/storage';
import Loader from 'halogen/ClipLoader';
import Comment from './Comment';
import Post from './Post';
class Comments extends Component {
constructor (props) {
super(props);
console.log('props comments');
console.log(props);
/*load comments*/
const {pid} = this.props.params;
const {dispatch} = this.props;
dispatch(actions.reqComments(pid,()=>null));
}
componentWillMount() {
// /*load comments*/
// const {pid} = this.props.params;
// const {dispatch} = this.props;
// dispatch(actions.reqComments(pid));
}
handleReply(evt){
evt.preventDefault();
const {dispatch} = this.props;
const {pid} = this.props.params;
const user = storage.get('user');
console.log(this.props);
console.dir('REPLYYYYYYYYYY');
console.log(pid);
console.log(user);
let comment = this.refs.replybox.value;
this.refs.replybox.value = '';
actions.createComment(pid,user,comment);
}
refresh(){
const {pid} = this.props.params;
const {dispatch} = this.props;
dispatch(actions.reqComments(pid));
}
render(){
console.log('STATETETE');
var pid = this.props.params.pid;
const {comments, isFetching} = this.props;
const mycomments = comments[pid];
console.log('comments reducer **************');
console.log(mycomments);
console.log(pid);
console.log(comments);
console.log(isFetching);
// || isFetching===null || mycomments==undefined
if (isFetching===true || mycomments==undefined) {
return (
<div classNameName="container">
<div className="container">
<div className="row">
<div className="comment-section col-sm-12">
<h3>{pid} comments</h3>
</div>
</div>
<div className="row">
<div className="col-sm-5"></div>
</div>
<Loader color="#26A65B" size="64px" margin="4px"/>
<button onClick={this.refresh.bind(this)}> refresh comments </button>
</div>
</div>
);
}else{
return (
<div classNameName="container">
<div className="container">
<div className="row">
<div className="comment-section col-sm-12">
<h3>{pid} comments</h3>
</div>
</div>
<button onClick={this.refresh.bind(this)}> refresh comments </button>
<div className="row">
<div className="col-sm-5">
<form role="form">
<div className="form-group">
<label htmlFor="comment">Comment:</label>
<textarea ref='replybox' className="form-control" rows="5" id="comment"></textarea>
<button onClick={this.handleReply.bind(this)} type="submit">Reply</button>
</div>
</form>
</div>
</div>
<ul>
{mycomments.map((comment, i) =>
<Comment handleComments={this.handleReply.bind(this)} key={i} {...comment}/>
)}
</ul>
</div>
</div>
);
}
}
}
Comments.propTypes = {
params: PropTypes.object.isRequired,
dispatch: PropTypes.func.isRequired,
pid: PropTypes.any,
user: PropTypes.string,
comments: PropTypes.any,
isFetching: PropTypes.boolean
};
function mapStateToProps(state){
return {
comments: state.commentsReducer.comments,
isFetching: state.commentsReducer.isFetchingComments
};
}
export default connect(mapStateToProps)(Comments); |
from typing import Optional
from flask_wtf import FlaskForm
from wtforms import StringField, SelectField, SubmitField
from wtforms.validators import DataRequired, Length, Email
from servicex.models import UserModel
class ProfileForm(FlaskForm):
name = StringField('Full Name', validators=[DataRequired(), Length(0, 120)])
email = StringField('Email', validators=[DataRequired(), Email()])
institution = StringField('Institution', validators=[DataRequired()])
experiment = SelectField('Experiment', validators=[DataRequired()],
choices=[("ATLAS", "ATLAS"), ("CMS", "CMS")],
default="ATLAS")
submit = SubmitField('Save Profile')
def __init__(self, user: Optional[UserModel] = None):
super().__init__()
if user:
self.name.data = user.name
self.email.data = user.email
self.institution.data = user.institution
self.experiment.data = user.experiment
|
var min=document.getElementById('min').innerHTML;
min=parseInt(min);
var conv=document.getElementById('conv').innerHTML;
conv=parseInt(conv);
var sup=document.getElementById('sup').innerHTML;
sup=parseInt(sup);
var partidos=conv+sup;
document.getElementById('min_par').innerHTML=min/partidos;
var gol=document.getElementById('gol').innerHTML;
gol=parseInt(gol);
var gol_par=gol/partidos;
document.getElementById('goles_partido').innerHTML=gol_par;
document.getElementById('partidos').innerHTML=100;
document.getElementById('partidos').innerHTML=partidos;
document.getElementById('goles_partido').innerHTML=gol/partidos;
document.getElementById('porconv').innerHTML=(conv/partidos)*100 + "%";
document.getElementById('porsup').innerHTML=(sup/partidos)*100 + "%";
|
#users/admin.py
import sys
sys.path.insert(0,'..')
import questions_and_answers
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
import pprint
from .forms import CustomUserCreation, CustomUserChange
from .models import CustomUser
from slam.questions_and_answers import fields as f
tpl = ['email', 'last_response', 'intro', 'out']
for key in f.keys():
tpl.extend([key + '_q', key + '_h'])
class CustomUserAdmin(UserAdmin):
add_form = CustomUserCreation
form = CustomUserChange
list_display = ['email', 'username', 'id']
fieldsets = (
(None, {'fields': ('username', 'password')}),
(('Personal info'), {'fields': tuple(tpl)}),
)
model = CustomUser
admin.site.register(CustomUser, CustomUserAdmin)
|
# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# 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.
#
# Generated code. DO NOT EDIT!
#
# Snippet for ListExclusions
# NOTE: This snippet has been automatically generated for illustrative purposes only.
# It may require modifications to work in your environment.
# To install the latest published package dependency, execute the following:
# python3 -m pip install google-cloud-logging
# [START logging_generated_logging_v2_ConfigServiceV2_ListExclusions_async]
from google.cloud import logging_v2
async def sample_list_exclusions():
# Create a client
client = logging_v2.ConfigServiceV2AsyncClient()
# Initialize request argument(s)
project = "my-project-id"
exclusion = "exclusion_value"
parent = f"projects/{project}/exclusions/{exclusion}"
request = logging_v2.ListExclusionsRequest(
parent=parent,
)
# Make the request
page_result = client.list_exclusions(request=request)
async for response in page_result:
print(response)
# [END logging_generated_logging_v2_ConfigServiceV2_ListExclusions_async]
|
import { render, screen } from '@testing-library/react';
import Footer from './index';
test('renders correctly', () => {
render(<Footer />);
const footer = screen.getAllByTestId('footer');
expect(screen.getByTestId('footer_left')).toHaveTextContent('EasyBanking POC web app');
expect(screen.getByTestId('footer_right')).toHaveTextContent('©Alex Baranova');
}); |
window.setTimeout(function () {
document.location.href = "/game";
}, 4000);
|
# Set Example
myset = {"Joseph", "Adaobi", "Kamara", "Ugochi"}
# Loop through set
for i in myset:
print(i)
#checking wheter 2 exists in myset
print(2 in myset)
#adding new element
myset.add(99)
print(myset)
|
/*!
* CanJS - 2.3.23
* http://canjs.com/
* Copyright (c) 2016 Bitovi
* Fri, 08 Apr 2016 17:58:15 GMT
* Licensed MIT
*/
/*[email protected]#compute/get_value_and_bind*/
steal('can/util', function (can) {
function ObservedInfo(func, context, compute) {
this.newObserved = {};
this.oldObserved = null;
this.func = func;
this.context = context;
this.compute = compute;
this.onDependencyChange = can.proxy(this.onDependencyChange, this);
this.depth = null;
this.childDepths = {};
this.ignore = 0;
this.inBatch = false;
this.ready = false;
compute.observedInfo = this;
this.setReady = can.proxy(this._setReady, this);
}
can.simpleExtend(ObservedInfo.prototype, {
getPrimaryDepth: function () {
return this.compute._primaryDepth;
},
_setReady: function () {
this.ready = true;
},
getDepth: function () {
if (this.depth !== null) {
return this.depth;
} else {
return this.depth = this._getDepth();
}
},
_getDepth: function () {
var max = 0, childDepths = this.childDepths;
for (var cid in childDepths) {
if (childDepths[cid] > max) {
max = childDepths[cid];
}
}
return max + 1;
},
addEdge: function (objEv) {
objEv.obj.bind(objEv.event, this.onDependencyChange);
if (objEv.obj.observedInfo) {
this.childDepths[objEv.obj._cid] = objEv.obj.observedInfo.getDepth();
this.depth = null;
}
},
removeEdge: function (objEv) {
objEv.obj.unbind(objEv.event, this.onDependencyChange);
if (objEv.obj.observedInfo) {
delete this.childDepths[objEv.obj._cid];
this.depth = null;
}
},
dependencyChange: function (ev) {
if (this.bound && this.ready) {
if (ev.batchNum !== undefined) {
if (ev.batchNum !== this.batchNum) {
ObservedInfo.registerUpdate(this);
this.batchNum = ev.batchNum;
}
} else {
this.updateCompute(ev.batchNum);
}
}
},
onDependencyChange: function (ev, newVal, oldVal) {
this.dependencyChange(ev, newVal, oldVal);
},
updateCompute: function (batchNum) {
if (this.bound) {
var oldValue = this.value;
this.getValueAndBind();
this.compute.updater(this.value, oldValue, batchNum);
}
},
getValueAndBind: function () {
this.bound = true;
this.oldObserved = this.newObserved || {};
this.ignore = 0;
this.newObserved = {};
this.ready = false;
observedInfoStack.push(this);
this.value = this.func.call(this.context);
observedInfoStack.pop();
this.updateBindings();
can.batch.afterPreviousEvents(this.setReady);
},
updateBindings: function () {
var newObserved = this.newObserved, oldObserved = this.oldObserved, name, obEv;
for (name in newObserved) {
obEv = newObserved[name];
if (!oldObserved[name]) {
this.addEdge(obEv);
} else {
oldObserved[name] = null;
}
}
for (name in oldObserved) {
obEv = oldObserved[name];
if (obEv) {
this.removeEdge(obEv);
}
}
},
teardown: function () {
this.bound = false;
for (var name in this.newObserved) {
var ob = this.newObserved[name];
this.removeEdge(ob);
}
this.newObserved = {};
}
});
var updateOrder = [], curPrimaryDepth = Infinity, maxPrimaryDepth = 0;
ObservedInfo.registerUpdate = function (observeInfo, batchNum) {
var depth = observeInfo.getDepth() - 1;
var primaryDepth = observeInfo.getPrimaryDepth();
curPrimaryDepth = Math.min(primaryDepth, curPrimaryDepth);
maxPrimaryDepth = Math.max(primaryDepth, maxPrimaryDepth);
var primary = updateOrder[primaryDepth] || (updateOrder[primaryDepth] = {
observeInfos: [],
current: Infinity,
max: 0
});
var objs = primary.observeInfos[depth] || (primary.observeInfos[depth] = []);
objs.push(observeInfo);
primary.current = Math.min(depth, primary.current);
primary.max = Math.max(depth, primary.max);
};
ObservedInfo.batchEnd = function (batchNum) {
var cur;
while (true) {
if (curPrimaryDepth <= maxPrimaryDepth) {
var primary = updateOrder[curPrimaryDepth];
if (primary && primary.current <= primary.max) {
var last = primary.observeInfos[primary.current];
if (last && (cur = last.pop())) {
cur.updateCompute(batchNum);
} else {
primary.current++;
}
} else {
curPrimaryDepth++;
}
} else {
updateOrder = [];
curPrimaryDepth = Infinity;
maxPrimaryDepth = 0;
return;
}
}
};
var observedInfoStack = [];
can.__observe = function (obj, event) {
var top = observedInfoStack[observedInfoStack.length - 1];
if (top && !top.ignore) {
var evStr = event + '', name = obj._cid + '|' + evStr;
if (top.traps) {
top.traps.push({
obj: obj,
event: evStr,
name: name
});
} else if (!top.newObserved[name]) {
top.newObserved[name] = {
obj: obj,
event: evStr
};
}
}
};
can.__reading = can.__observe;
can.__trapObserves = function () {
if (observedInfoStack.length) {
var top = observedInfoStack[observedInfoStack.length - 1];
var traps = top.traps = [];
return function () {
top.traps = null;
return traps;
};
} else {
return function () {
return [];
};
}
};
can.__observes = function (observes) {
var top = observedInfoStack[observedInfoStack.length - 1];
if (top) {
for (var i = 0, len = observes.length; i < len; i++) {
var trap = observes[i], name = trap.name;
if (!top.newObserved[name]) {
top.newObserved[name] = trap;
}
}
}
};
can.__isRecordingObserves = function () {
var len = observedInfoStack.length;
return len && observedInfoStack[len - 1].ignore === 0;
};
can.__notObserve = function (fn) {
return function () {
if (observedInfoStack.length) {
var top = observedInfoStack[observedInfoStack.length - 1];
top.ignore++;
var res = fn.apply(this, arguments);
top.ignore--;
return res;
} else {
return fn.apply(this, arguments);
}
};
};
can.batch._onDispatchedEvents = ObservedInfo.batchEnd;
return ObservedInfo;
}); |
from core import scratch
from core.scratchpy.parser import SPModuleParser
from core.scratchpy.compiler2 import SPModuleCompiler
parser = SPModuleParser()
with open("vm.sp") as fl:
text = fl.read()
module = parser.parseText(text)
#print(module.functionBlocks[0].body)
#print(module.functionBlocks[1].body)
compiler = SPModuleCompiler(module)
compiler.compileModule()
compiler.exportSB3("test.sb3")
compiler.exportProjectJSON("test.json") |
import React from 'react';
import ReactDom from 'react-dom';
import './index.css'
const root = document.getElementById('root');
function Square(props) {
return (
<button className="square" onClick={props.onClick} >
{props.value}
</button>
)
}
class Board extends React.Component {
renderSquare(i) {
return <Square
value={this.props.squares[i]}
onClick={()=> this.props.onClick(i)}
/>
}
render() {
return(
<div>
<div className="boar-row">
{this.renderSquare(0)}
{this.renderSquare(1)}
{this.renderSquare(2)}
</div>
<div className="boar-row">
{this.renderSquare(3)}
{this.renderSquare(4)}
{this.renderSquare(5)}
</div>
<div className="boar-row">
{this.renderSquare(6)}
{this.renderSquare(7)}
{this.renderSquare(8)}
</div>
</div>
);
}
}
class Game extends React.Component {
constructor(props) {
super(props);
this.state = {
history: [{
squares: Array(9).fill(null)
}],
stepNumber: 0,
xIsNext: true
}
}
handleClick(i) {
//console.log(i)
const history = this.state.history.slice(0, this.state.stepNumber + 1);
//console.log(history)
const current = history[history.length - 1];
const squares = current.squares.slice();
if (calculateWinner(squares) || squares[i]){
return;
}
squares[i] = this.state.xIsNext ? 'X' : 'O';
this.setState({
history: history.concat([{
squares: squares,
}]),
stepNumber: history.length,
xIsNext: !this.state.xIsNext,
});
}
jumpTo(step){
this.setState({
stepNumber: step,
xIsNext: (step % 2) === 0,
})
}
render() {
const history = this.state.history;
const current = history[this.state.stepNumber];
const winner = calculateWinner(current.squares);
const moves = history.map((steps, move) => {
const desc = move ? 'move ' + move : 'Game start';
return(
<li key={move}>
<button onClick={() => this.jumpTo(move)}>{desc}</button>
</li>
)
});
let status;
if(winner){
status = 'Winner ' + winner;
}else{
status = 'Player '+(this.state.xIsNext ? 'X' : 'O');
}
return (
<div className='game'>
<div className='game-board'>
<Board
squares={current.squares}
onClick={(i) => this.handleClick(i)}
/>
</div>
<div className='game-info'>
<div>{status}</div>
<ol>{moves}</ol>
</div>
</div>
);
}
}
function calculateWinner(squares) {
const lines = [
[0,1,2],
[3,4,5],
[6,7,8],
[0,3,6],
[1,4,7],
[2,5,8],
[1,4,8],
[2,4,6],
]
//console.log(squares)
for (let i = 0; i < lines.length; i++) {
const [a,b,c] = lines[i];
if (squares[a] && squares[a] === squares[b] && squares[a] === squares[c]){
return squares[a]
}
}
return null
}
ReactDom.render(<Game />, root) |
from dataclasses import dataclass, field
from dataclasses_json import dataclass_json, Undefined, config
from typing import Optional, TYPE_CHECKING
from uuid import UUID
import os
import hashlib
@dataclass_json(undefined=Undefined.EXCLUDE)
@dataclass
class PesertaDidik:
registrasi_id: UUID
peserta_didik_id: UUID
jenis_pendaftaran_id: int
jenis_pendaftaran_id_str: str
tanggal_masuk_sekolah: str
nik: str
nisn: str
nama: str
tingkat_pendidikan_id: int
nama_rombel: str
jenis_kelamin: str
tempat_lahir: str
tanggal_lahir: str
agama_id: int
agama_id_str: str
alamat_jalan: str
nipd: Optional[str] = field(
default=None, metadata=config(exclude=lambda x: x is None)
)
email: Optional[str] = None
nomor_telepon_rumah: Optional[str] = None
nomor_telepon_seluler: Optional[str] = None
def __str__(self):
return self.nama
def memberId(self):
return self.nipd
def toSlims(self):
return {
'member_id': self.nipd,
'member_name': self.nama.title(),
'gender': (0 if self.jenis_kelamin == "P" else 1),
'member_type_id': os.getenv('SLIMS_MEMBERSHIP_STUDENT_ID'),
'member_email': self.email,
'member_address': self.alamat_jalan,
'inst_name': self.nama_rombel,
'pin': self.nipd,
'member_phone': self.nomor_telepon_seluler,
'member_fax': self.nomor_telepon_rumah,
'member_since_date': self.tanggal_masuk_sekolah,
'register_date': self.tanggal_masuk_sekolah,
'expire_date': '2099-12-1', # Placeholder
'birth_date': self.tanggal_lahir,
'input_date': self.tanggal_masuk_sekolah,
'last_update': self.tanggal_masuk_sekolah,
'member_notes': '',
'mpasswd': hashlib.md5(
str(self.nipd).encode('utf-8')
).hexdigest()
}
|
import { storiesOf } from '@storybook/vue'
import RplAnchorLinks from './index.vue'
import {
withKnobs,
text,
object
} from '@storybook/addon-knobs/vue'
storiesOf('Molecules/AnchorLinks', module)
.addDecorator(withKnobs)
.add('Anchor Links', () => ({
components: { RplAnchorLinks },
template: `<rpl-anchor-links :title="title" :links="links" />`,
props: {
title: {
default: text('Title', 'On this page:')
},
links: {
default: () => object('Links', [
{ text: 'This is the first anchor link', url: '#' },
{ text: 'Second link to extra content', url: '#' },
{ text: 'Third link goes here', url: '#' },
{ text: 'Link to additional content', url: '#' },
{ text: 'Another link to extra content', url: '#' },
{ text: 'This is another link', url: '#' }
])
}
}
}))
|
$(function() {
var timeid = query = null;
var controlLink = $('#control');
var errmsg = $('<p class="errmsg">'+Database.errmsg+'</p>')
.insertBefore(controlLink)
.hide();
var loading = $('<img class="loading" alt="[loading]" src="'+ Database.load_icon +'" />')
.insertAfter(controlLink)
.hide();
function refreshTable() {
if (Database.ajax_time_refresh > 0) {
loading.show();
query = $.ajax({
type: 'GET',
dataType: 'html',
data: {server: Database.server, database: Database.dbname, action: Database.action},
url: 'database.php',
cache: false,
contentType: 'application/x-www-form-urlencoded',
success: function(html) {
$('#data_block').html(html);
timeid = window.setTimeout(refreshTable, Database.ajax_time_refresh)
},
error: function() {
controlLink.click();
errmsg.show();
},
complete: function () {
loading.hide();
}
});
}
}
controlLink.on('click', function() {
if (!timeid) {
$(errmsg).hide();
timeid = window.setTimeout(refreshTable, Database.ajax_time_refresh);
controlLink.html('<img src="'+ Database.str_stop.icon +'" alt="" /> '
+ Database.str_stop.text + ' '
);
} else {
$(errmsg).hide();
$(loading).hide();
window.clearInterval(timeid);
timeid = null;
if (query) query.abort();
controlLink.html('<img src="'+ Database.str_start.icon +'" alt="" /> '
+ Database.str_start.text
);
}
return false; /* disable event propagation */
});
/* preload images */
$('#control img').hide()
.attr('src', Database.str_start.icon)
.attr('src', Database.str_stop.icon)
.show();
/* start refreshing */
controlLink.trigger('click');
});
|
N, K = map(int, input().split())
X = list(map(int, input().split()))
ans = 1e10
for i in range(N - K + 1):
left = X[i]
right = X[i + K - 1]
ans = min(ans, min(abs(left), abs(right)) + abs(left - right))
print(ans)
|
import React from "react";
export default function Euro() {
return (
<svg
xmlns="http://www.w3.org/2000/svg"
width="24"
height="24"
viewBox="0 0 24 24"
>
<path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z" />
<path fill="none" d="M0 0h24v24H0z" />
</svg>
);
}
|
deepmacDetailCallback("0008c5000000/24",[{"d":"2001-12-23","t":"add","a":"306, Wooyoung Techno Center, 273-15,\nSungsu2ga-3dong, Sungdong-ku,\nSeoul 133-831\n","c":"KOREA, DEMOCRATIC PEOPLE'S REPUBLI","o":"Liontech Co., Ltd.","s":"wireshark.org"},{"d":"2004-06-05","t":"change","a":"306, Wooyoung Techno Center, 273-15,\nSungsu2ga-3dong, Sungdong-ku,\nSeoul 133-831\n","c":"KOREA, REPUBLIC OF","o":"Liontech Co., Ltd."},{"d":"2015-08-27","t":"change","a":"306, Wooyoung Techno Center, 273-15, Seoul KR 133-831","c":"KR","o":"Liontech Co., Ltd."}]);
|
import React, {Component} from 'react';
import {
Text,
View,
TouchableOpacity,
StyleSheet,
Alert,
Platform,
Dimensions,
TextInput,
Picker,
ScrollView,
ListView,
Image
} from 'react-native';
import { Card, CardSection, Input, Button2, InfoBox, InfoBox2, TitleBox } from './common';
import ActionButton from 'react-native-action-button';
import Modal from 'react-native-simple-modal';
import { firebaseApp } from '../app.js';
var {height, width} = Dimensions.get('window');
const Item = Picker.Item;
export default class CustomerDetail extends Component {
static navigatorButtons = {
leftButtons: [{
icon: require('../../img/navicon_menu.png'),
id: 'menu'
}],
};
static navigatorStyle = {
navBarBackgroundColor: '#336600',
navBarTextColor: 'white',
navBarSubtitleTextColor: '#ff0000',
navBarButtonColor: '#ffffff',
statusBarTextColorScheme: 'light',
tabBarBackgroundColor: '#4dbce9',
tabBarButtonColor: '#ffffff',
tabBarSelectedButtonColor: '#ffff00'
};
constructor(props) {
super(props);
this.state={
diachi:'',
content :'',
plan: '',
selected0: 'key0',
lastTime:'16/12',
openModal:false,
newContent: '',
contentSource: new ListView.DataSource({rowHasChanged: (row1, row2) => row1 !== row2})
};
this.items = [];
this.itemsRef = firebaseApp.database().ref("contentlist");
this.props.navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));
}
onNavigatorEvent(event) {
if (event.id === 'menu') {
this.props.navigator.toggleDrawer({
side: 'left',
animated: true
});
}
}
componentDidMount() {
this.itemsRef.on('child_added',(dataSnapshot) => {
this.items.push({id: dataSnapshot.key, text:dataSnapshot.val()});
this.setState({
contentSource: this.state.contentSource.cloneWithRows(this.items)
})
});
this.itemsRef.on('child_removed',(dataSnapshot) => {
this.items = this.items.filter((x) => x.id !== dataSnapshot.key);
this.setState({
contentSource: this.state.contentSource.cloneWithRows(this.items)
})
});
}
addContent() {
if(this.state.newContent !== '') {
this.itemsRef.push({
content: this.state.newContent
})
this.setState({
newContent: '',
openModal: false
})
}
}
removeContent(rowData) {
this.itemsRef.child(rowData.id).remove();
}
onValueChange(key, value) {
const newState = {};
newState[key] = value;
this.setState(newState);
};
backCustomer(){
Alert.alert('Next');
};
nextCustomer(){
Alert.alert('Next');
}
renderRow(rowData) {
return (
<View style={{flexDirection:'row', width:width-33, height: 80}}>
<TouchableOpacity onPress={() => this.removeContent(rowData)} style={{justifyContent:'center', alignItems:'center'}}>
<Image
style={{height:30, width:30}}
source={require('../../res/img/remove-icon.png')}/>
</TouchableOpacity>
<TitleBox title='Nội dung cuộc gọi:'>
<Text style={{color:'black', fontSize:16, width: width-30}}>{rowData.text.content}
</Text>
</TitleBox>
</View>
);
}
render() {
return (
<View style={styles.container}>
<ScrollView >
<View style={{flexDirection:'row', width:width}}>
<View style={{flex:1}}>
<InfoBox title='Mã KH:' content='CD123' />
<InfoBox title='Họ tên:' content='Thanh niên chuyên cần' />
<InfoBox title='Điện thoại' content='0123.456.789' />
</View>
<View style={{flex:1}}>
<InfoBox title='Địa chỉ:' content='612 La Thành - Hà Nội' />
<InfoBox title='Email:' content='khanhqd.neu@gmail' />
<InfoBox title='Ngày sinh:' content='11.22.1989' />
</View>
</View>
<InfoBox title='Nhân viên phụ trách:' content='Quách Khánh' />
<TitleBox title='Trạng Thái:'>
<Picker
style={styles.picker}
selectedValue={this.state.selected0}
onValueChange={this.onValueChange.bind(this, 'selected0')}>
<Item label="Chưa xử lý" value="key0" />
<Item label="Gọi không thành công" value="key1" />
<Item label="Đã hẹn" value="key2" />
<Item label="Đã gặp trực tiếp" value="key3" />
</Picker>
</TitleBox>
<InfoBox title='Nội dung cuộc gọi ({this.state.lastTime}):' content='Muốn mua tủ lạnh' />
<InfoBox title='Kế hoạch:' content='Cần tư vấn đến ĐMX' />
<ListView
dataSource={this.state.contentSource}
renderRow={this.renderRow.bind(this)}
/>
</ScrollView>
<ActionButton
buttonColor="#32B34E"
onPress={() => {this.setState({openModal: true})}}
/>
<Modal
open={this.state.openModal}
modalDidOpen={() => console.log('modal did open')}
modalDidClose={() => this.setState({openModal: false})}
closeOnTouchOutside={true}
style={{alignItems: 'center'}}>
<View >
<Text style={{fontSize: 20, marginBottom: 10, fontWeight:'bold'}}>Thêm nội dung mới:</Text>
<TextInput
placeholder="nội dung..."
style={styles.input}
value={this.state.newContent}
onChangeText={(content) => this.setState({newContent: content})}/>
<View style={{flexDirection:'row'}}>
<Button2
onPress={() => this.setState({openModal: false})}
title='Cancel'/>
<Button2
onPress={() => this.addContent()}
title='OK'/>
</View>
</View>
</Modal>
</View>
);
}
}
const styles = StyleSheet.create({
container:{
backgroundColor: '#CACACA',
flex:1,
paddingTop:5
},
titleContainer:{
borderBottomWidth: 0.5,
borderTopLeftRadius: 3,
borderTopRightRadius: 2.5,
borderBottomColor: '#d6d7da',
backgroundColor: '#f6f7f8',
paddingHorizontal: 10,
paddingVertical: 5,
},
textTitle:{
color:'black',
paddingLeft:20,
fontSize:15,
fontWeight:'bold'
},
textBox:{
fontSize:15,
padding:10,
paddingLeft:30
},
box:{
borderRadius: 3,
borderWidth: 0.5,
borderColor: '#d6d7da',
backgroundColor: '#ffffff',
margin: 5,
marginVertical: 1,
overflow: 'hidden',
},
picker: {
width: width,
backgroundColor:'white',
paddingLeft:30,
},
input: {
color: '#000',
paddingRight: 5,
paddingLeft: 5,
fontSize:16,
},
});
|
domain_name = os.environ.get("DOMAIN_NAME", "wldomain")
domain_path = '/apps/oracle/%s' % domain_name
db_user_chipsDS = os.environ.get("DB_USER_CHIPSDS", 'db_user_chipsds_missing')
db_password_chipsDS = os.environ.get("DB_PASSWORD_CHIPSDS", 'db_password_chipsds_missing')
db_url_chipsDS = os.environ.get("DB_URL_CHIPSDS", 'db_url_chipsds_missing')
db_user_staffDS = os.environ.get("DB_USER_STAFFDS", 'db_user_staffds_missing')
db_password_staffDS = os.environ.get("DB_PASSWORD_STAFFDS", 'db_password_staffds_missing')
db_url_staffDS = os.environ.get("DB_URL_STAFFDS", 'db_url_staffds_missing')
print('domain_name : [%s]' % domain_name);
print('domain_path : [%s]' % domain_path);
print('db_url_chipsDS : [%s]' % db_url_chipsDS);
print('db_url_staffDS : [%s]' % db_url_staffDS);
# Open the domain
# ======================
readDomain(domain_path)
cd('/JDBCSystemResource/chipsDS/JdbcResource/chipsDS/JDBCDriverParams/NO_NAME_0')
set('PasswordEncrypted', db_password_chipsDS)
cmo.setUrl(db_url_chipsDS)
cd('/JDBCSystemResource/chipsDS/JdbcResource/chipsDS/JDBCDriverParams/NO_NAME_0/Properties/NO_NAME_0/Property/user')
cmo.setValue(db_user_chipsDS)
cd('/JDBCSystemResource/chipsBulkDS/JdbcResource/chipsBulkDS/JDBCDriverParams/NO_NAME_0')
set('PasswordEncrypted', db_password_chipsDS)
cmo.setUrl(db_url_chipsDS)
cd('/JDBCSystemResource/chipsBulkDS/JdbcResource/chipsBulkDS/JDBCDriverParams/NO_NAME_0/Properties/NO_NAME_0/Property/user')
cmo.setValue(db_user_chipsDS)
cd('/JDBCSystemResource/staffwareDs/JdbcResource/staffwareDs/JDBCDriverParams/NO_NAME_0')
set('PasswordEncrypted', db_password_staffDS)
cmo.setUrl(db_url_staffDS)
cd('/JDBCSystemResource/staffwareDs/JdbcResource/staffwareDs/JDBCDriverParams/NO_NAME_0/Properties/NO_NAME_0/Property/user')
cmo.setValue(db_user_staffDS)
# Write Domain
# ============
updateDomain()
closeDomain()
# Exit WLST
# =========
exit()
|
"""Defines common errors raised from function binding."""
class NoPoolSetError(Exception):
"""Raised when there is no pool set for a function binder before a sql operation is called."""
pass
class PoolAlreadySetError(Exception):
"""Raised when a pool is set twice on a binder."""
pass
class BindingError(Exception):
"""Base exception for errors when binding functions."""
pass
class MappingError(Exception):
"""Base exception for errors related to mapping database results to return types."""
pass
class TemplateError(BindingError):
"""Raised when parsing a template fails."""
pass
class FunctionAlreadyBoundError(BindingError):
"""Raised when a function is bound more than once to a query, execution, or transaction."""
pass
class SignatureError(BindingError):
"""Base exception for binding errors related to function signature inspection."""
pass
class BadReturnTypeError(SignatureError):
"""Raised when a return hint specifies a type that cannot be used for mapping in the context of the binding."""
pass
class MissingTemplateArgumentError(SignatureError):
"""Raised when a template specifies an argument not found in its bounded function's signature."""
pass
class CannotInferMappingError(SignatureError):
"""Raised when the return mapping for a bound function cannot be determined."""
pass
class MultipleConnectionArgumentError(SignatureError):
"""Raised when a bound function specifies multiple connection arguments."""
pass
class TooManyValuesError(MappingError):
"""Raised when the number of columns does not match the expected number for mapping."""
pass
class TooManyRowsError(MappingError):
"""Raised when mapping implies a singular return, but many rows are returned."""
pass
|
/**
* @license NgRx 6.1.0
* (c) 2015-2018 Brandon Roberts, Mike Ryan, Rob Wormald, Victor Savkin
* License: MIT
*/
import { Inject, InjectionToken, NgModule } from '@angular/core';
import { NavigationCancel, NavigationError, NavigationEnd, Router, RoutesRecognized } from '@angular/router';
import { select, Store } from '@ngrx/store';
import { of } from 'rxjs';
var RouterStateSerializer = /** @class */ (function () {
function RouterStateSerializer() {
}
return RouterStateSerializer;
}());
var DefaultRouterStateSerializer = /** @class */ (function () {
function DefaultRouterStateSerializer() {
}
DefaultRouterStateSerializer.prototype.serialize = function (routerState) {
return {
root: this.serializeRoute(routerState.root),
url: routerState.url,
};
};
DefaultRouterStateSerializer.prototype.serializeRoute = function (route) {
var _this = this;
var children = route.children.map(function (c) { return _this.serializeRoute(c); });
return {
params: route.params,
paramMap: route.paramMap,
data: route.data,
url: route.url,
outlet: route.outlet,
routeConfig: {
component: route.routeConfig ? route.routeConfig.component : undefined,
},
queryParams: route.queryParams,
queryParamMap: route.queryParamMap,
fragment: route.fragment,
component: (route.routeConfig
? route.routeConfig.component
: undefined),
root: undefined,
parent: undefined,
firstChild: children[0],
pathFromRoot: undefined,
children: children,
};
};
return DefaultRouterStateSerializer;
}());
var __assign = (undefined && undefined.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
/**
* An action dispatched when the router navigates.
*/
var ROUTER_NAVIGATION = 'ROUTER_NAVIGATION';
/**
* An action dispatched when the router cancels navigation.
*/
var ROUTER_CANCEL = 'ROUTER_CANCEL';
/**
* An action dispatched when the router errors.
*/
var ROUTER_ERROR = 'ROUTE_ERROR';
function routerReducer(state, action) {
switch (action.type) {
case ROUTER_NAVIGATION:
case ROUTER_ERROR:
case ROUTER_CANCEL:
return {
state: action.payload.routerState,
navigationId: action.payload.event.id,
};
default:
return state;
}
}
var _ROUTER_CONFIG = new InjectionToken('@ngrx/router-store Internal Configuration');
var ROUTER_CONFIG = new InjectionToken('@ngrx/router-store Configuration');
var DEFAULT_ROUTER_FEATURENAME = 'routerReducer';
function _createDefaultRouterConfig(config) {
var _config;
if (typeof config === 'function') {
_config = config();
}
else {
_config = config || {};
}
return __assign({ stateKey: DEFAULT_ROUTER_FEATURENAME }, _config);
}
var ɵ0 = { stateKey: DEFAULT_ROUTER_FEATURENAME };
/**
* Connects RouterModule with StoreModule.
*
* During the navigation, before any guards or resolvers run, the router will dispatch
* a ROUTER_NAVIGATION action, which has the following signature:
*
* ```
* export type RouterNavigationPayload = {
* routerState: SerializedRouterStateSnapshot,
* event: RoutesRecognized
* }
* ```
*
* Either a reducer or an effect can be invoked in response to this action.
* If the invoked reducer throws, the navigation will be canceled.
*
* If navigation gets canceled because of a guard, a ROUTER_CANCEL action will be
* dispatched. If navigation results in an error, a ROUTER_ERROR action will be dispatched.
*
* Both ROUTER_CANCEL and ROUTER_ERROR contain the store state before the navigation
* which can be used to restore the consistency of the store.
*
* Usage:
*
* ```typescript
* @NgModule({
* declarations: [AppCmp, SimpleCmp],
* imports: [
* BrowserModule,
* StoreModule.forRoot(mapOfReducers),
* RouterModule.forRoot([
* { path: '', component: SimpleCmp },
* { path: 'next', component: SimpleCmp }
* ]),
* StoreRouterConnectingModule
* ],
* bootstrap: [AppCmp]
* })
* export class AppModule {
* }
* ```
*/
var StoreRouterConnectingModule = /** @class */ (function () {
function StoreRouterConnectingModule(store, router, serializer, config) {
this.store = store;
this.router = router;
this.serializer = serializer;
this.config = config;
this.dispatchTriggeredByRouter = false;
this.navigationTriggeredByDispatch = false;
this.stateKey = this.config.stateKey;
this.setUpBeforePreactivationHook();
this.setUpStoreStateListener();
this.setUpStateRollbackEvents();
}
StoreRouterConnectingModule.forRoot = function (config) {
if (config === void 0) { config = {}; }
return {
ngModule: StoreRouterConnectingModule,
providers: [
{ provide: _ROUTER_CONFIG, useValue: config },
{
provide: ROUTER_CONFIG,
useFactory: _createDefaultRouterConfig,
deps: [_ROUTER_CONFIG],
},
],
};
};
StoreRouterConnectingModule.prototype.setUpBeforePreactivationHook = function () {
var _this = this;
this.router.hooks.beforePreactivation = function (routerState) {
_this.routerState = _this.serializer.serialize(routerState);
if (_this.shouldDispatchRouterNavigation()) {
_this.dispatchRouterNavigation();
}
return of(true);
};
};
StoreRouterConnectingModule.prototype.setUpStoreStateListener = function () {
var _this = this;
this.store.subscribe(function (s) {
_this.storeState = s;
});
this.store.pipe(select(this.stateKey)).subscribe(function () {
_this.navigateIfNeeded();
});
};
StoreRouterConnectingModule.prototype.shouldDispatchRouterNavigation = function () {
if (!this.storeState[this.stateKey])
return true;
return !this.navigationTriggeredByDispatch;
};
StoreRouterConnectingModule.prototype.navigateIfNeeded = function () {
if (!this.storeState[this.stateKey] ||
!this.storeState[this.stateKey].state) {
return;
}
if (this.dispatchTriggeredByRouter)
return;
if (this.router.url !== this.storeState[this.stateKey].state.url) {
this.navigationTriggeredByDispatch = true;
this.router.navigateByUrl(this.storeState[this.stateKey].state.url);
}
};
StoreRouterConnectingModule.prototype.setUpStateRollbackEvents = function () {
var _this = this;
this.router.events.subscribe(function (e) {
if (e instanceof RoutesRecognized) {
_this.lastRoutesRecognized = e;
}
else if (e instanceof NavigationCancel) {
_this.dispatchRouterCancel(e);
}
else if (e instanceof NavigationError) {
_this.dispatchRouterError(e);
}
else if (e instanceof NavigationEnd) {
_this.dispatchTriggeredByRouter = false;
_this.navigationTriggeredByDispatch = false;
}
});
};
StoreRouterConnectingModule.prototype.dispatchRouterNavigation = function () {
this.dispatchRouterAction(ROUTER_NAVIGATION, {
routerState: this.routerState,
event: new RoutesRecognized(this.lastRoutesRecognized.id, this.lastRoutesRecognized.url, this.lastRoutesRecognized.urlAfterRedirects, this.routerState),
});
};
StoreRouterConnectingModule.prototype.dispatchRouterCancel = function (event) {
this.dispatchRouterAction(ROUTER_CANCEL, {
routerState: this.routerState,
storeState: this.storeState,
event: event,
});
};
StoreRouterConnectingModule.prototype.dispatchRouterError = function (event) {
this.dispatchRouterAction(ROUTER_ERROR, {
routerState: this.routerState,
storeState: this.storeState,
event: new NavigationError(event.id, event.url, "" + event),
});
};
StoreRouterConnectingModule.prototype.dispatchRouterAction = function (type, payload) {
this.dispatchTriggeredByRouter = true;
try {
this.store.dispatch({ type: type, payload: payload });
}
finally {
this.dispatchTriggeredByRouter = false;
this.navigationTriggeredByDispatch = false;
}
};
StoreRouterConnectingModule.decorators = [
{ type: NgModule, args: [{
providers: [
{ provide: RouterStateSerializer, useClass: DefaultRouterStateSerializer },
{
provide: _ROUTER_CONFIG,
useValue: ɵ0,
},
{
provide: ROUTER_CONFIG,
useFactory: _createDefaultRouterConfig,
deps: [_ROUTER_CONFIG],
},
],
},] }
];
/** @nocollapse */
StoreRouterConnectingModule.ctorParameters = function () { return [
{ type: Store, },
{ type: Router, },
{ type: RouterStateSerializer, },
{ type: undefined, decorators: [{ type: Inject, args: [ROUTER_CONFIG,] },] },
]; };
return StoreRouterConnectingModule;
}());
/**
* DO NOT EDIT
*
* This file is automatically generated at build
*/
/**
* Generated bundle index. Do not edit.
*/
export { _ROUTER_CONFIG as ɵngrx_modules_router_store_router_store_a, _createDefaultRouterConfig as ɵngrx_modules_router_store_router_store_b, ROUTER_ERROR, ROUTER_CANCEL, ROUTER_NAVIGATION, routerReducer, StoreRouterConnectingModule, ROUTER_CONFIG, DEFAULT_ROUTER_FEATURENAME, RouterStateSerializer, DefaultRouterStateSerializer };
//# sourceMappingURL=router-store.js.map
|
// @flow
import babelConfig from '../lib/utils/babel-config'
//TODO add mock for 'path'
test("work babelConfig with npm run develop", () => {
return expect(babelConfig('./.babelrc', 'develop').presets[0]).toContain("react-hmre")
})
test("work babelConfig with npm run build", () => {
return expect(babelConfig('./.babelrc').presets[0]).toContain("flow")
})
test("work babelConfig with npm run other scripts", () => {
return expect(babelConfig('./.babelrc').presets[0]).toContain("flow")
})
|
const { ethers } = require("hardhat");
async function main() {
const [deployer] = await ethers.getSigners();
console.log("Deploying contracts with the account:", deployer.address);
console.log("Account balance:", (await deployer.getBalance()).toString());
const Token = await ethers.getContractFactory("nAnimals");
const token = await Token.deploy("https://nanimals.mypinata.cloud/ipfs/QmX4fuBn6gEPqYsuWkXfLYMTveVPTMQ3wkP2hSjQUNCgBN/");
console.log("Token address:", token.address);
}
main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});
// Call npx hardhat run scripts/deploy.js --network matic |