def build(**kwargs):
wg = WikiGraph()
wg.wiki = kwargs["wiki"]
kwargs["version"] = dt.resolve_version(wg.wiki, kwargs["version"])
wg.version = kwargs["version"]
p, r, d, c, cl = _make_graph_components(**kwargs)
wg._pages = frozenbidict(p)
wg._redirects = r
wg._disambiguations = frozenbidict(d)
wg._categories = frozenbidict(c)
wg._category_links = cl
pages = wg.pages(redirect=True, disambi=True)
wg._wpd.build(pages)
return wg
class Tags(DictMixin):
FIELD_MAP = frozenbidict()
def __getitem__(self, key):
k = self.FIELD_MAP.get(key, key)
return super().__getitem__(k)
def __setitem__(self, key, value):
k = self.FIELD_MAP.get(key, key)
return super().__setitem__(k, value)
def __delitem__(self, key):
k = self.FIELD_MAP.get(key, key)
return super().__delitem__(k)
def __iter__(self):
return iter(
self.FIELD_MAP.inv.get(k, k) for k in self.__dict__
if not k.startswith('_') and not k == 'FIELD_MAP')
def __repr__(self, repr_dict=None):
repr_dict = {
self.FIELD_MAP.inv.get(k, k): v
for k, v in self.__dict__.items()
if not k.startswith('_') and not k == 'FIELD_MAP'
}
return super().__repr__(repr_dict=repr_dict)
def make_representation(*, _cfg):
representation = _cfg['representation'].configure(
EventRepresentationProcessor,
timing=_cfg['timing'].configure(BeatShiftTiming),
use_end_of_sequence_event=True)
vocab = dict(representation.vocab)
start_id = max(vocab.values()) + 1
vocab[('bos', )] = start_id
end_id = vocab[('eos', )]
representation.vocab = bidict.frozenbidict(vocab)
return representation, start_id, end_id
class Tags(AttrMapping):
"""Base class for tags objects.
Attributes:
FIELD_MAP (frozenbidict): A mapping of format-specific
field names to common aliases.
"""
FIELD_MAP = frozenbidict()
def __getattr__(self, attr):
a = self.FIELD_MAP.get(attr, attr)
return super().__getattr__(a)
def __setattr__(self, attr, value):
a = self.FIELD_MAP.get(attr, attr)
super().__setattr__(a, value)
def __delattr__(self, attr):
a = self.FIELD_MAP.get(attr, attr)
super().__delattr__(a)
def __getitem__(self, key):
k = self.FIELD_MAP.get(key, key)
return super().__getitem__(k)
def __setitem__(self, key, value):
k = self.FIELD_MAP.get(key, key)
super().__setitem__(k, value)
def __delitem__(self, key):
k = self.FIELD_MAP.get(key, key)
super().__delitem__(k)
def __iter__(self):
return iter(
self.FIELD_MAP.inv.get(k, k) for k in self.__dict__
if not k.startswith('_') and not k == 'FIELD_MAP')
def __repr__(self, repr_dict=None):
repr_dict = {
self.FIELD_MAP.inv.get(k, k): v
for k, v in self.__dict__.items()
if not k.startswith('_') and not k == 'FIELD_MAP'
}
return super().__repr__(repr_dict=repr_dict)
def __init__(self, **n_states):
self.state_names = list(n_states.keys())
state_sizes = list(n_states.values())
self.n_states = state_sizes
self.n_dimensions = len(self.n_states)
self.total_states = np.prod(self.n_states)
if self.n_dimensions > 1:
mesh = self.get_states_mesh().squeeze().T
mesh = list(map(tuple, mesh))
index = np.arange(len(mesh))
self.values_dict = frozenbidict(zip(mesh, index))
def test_Tags():
test_tags = Tags(key1='value1', key2='value2')
test_tags.FIELD_MAP = frozenbidict({'artist': 'key1', 'title': 'key2'})
assert test_tags['artist'] == test_tags['key1']
assert test_tags['title'] == test_tags['key2']
test_tags['key3'] = 'value3'
del test_tags['key3']
assert 'key3' not in test_tags
assert list(iter(test_tags)) == ['artist', 'title']
assert repr(
test_tags) == "<Tags ({'artist': 'value1', 'title': 'value2'})>"
class RIFFTags(Tags):
FIELD_MAP = frozenbidict(
{
'album': 'IPRD',
'artist': 'IART',
'comment': 'ICMT',
'copyright': 'ICOP',
'date': 'ICRD',
'encodedby': 'IENC',
'genre': 'IGNR',
'language': 'ILNG',
'rating': 'IRTD',
'title': 'INAM',
'tracknumber': 'ITRK'
}
)
@datareader
@classmethod
def load(cls, data):
if data.read(4) != b'INFO':
raise InvalidChunk('Valid RIFF INFO chunk not found.')
fields = {}
field = data.read(4)
while len(field):
size = struct.unpack('I', data.read(4))[0]
value = data.read(size).strip(b'\x00').decode('utf-8')
fields[field.decode('utf-8')] = value
b = data.read(1)
while b == b'\x00':
b = data.read(1)
if b:
data.seek(-1, os.SEEK_CUR)
field = data.read(4)
return cls(fields)
class RIFFTags(Tags):
FIELD_MAP = frozenbidict({
'album': 'IPRD',
'artist': 'IART',
'comment': 'ICMT',
'copyright': 'ICOP',
'date': 'ICRD',
'encodedby': 'IENC',
'genre': 'IGNR',
'language': 'ILNG',
'rating': 'IRTD',
'title': 'INAM',
'tracknumber': 'ITRK'
})
@classmethod
def load(cls, data):
if not isinstance(data, DataReader): # pragma: nocover
data = DataReader(data)
fields = {}
field = data.read(4)
while len(field):
size = struct.unpack('I', data.read(4))[0]
value = data.read(size).strip(b'\x00').decode('utf-8')
fields[field.decode('utf-8')] = value
b = data.read(1)
while b == b'\x00':
b = data.read(1)
if b:
data.seek(-1, os.SEEK_CUR)
field = data.read(4)
return cls(fields)
import pytest
from collections import Counter, OrderedDict, defaultdict
from bidict import bidict, frozenbidict, namedbidict
from itertools import product
class dictsubclass(dict):
pass
d = dict(H='hydrogen', He='helium')
c = Counter(d)
o = OrderedDict(d)
dd = defaultdict(int, d)
s = dictsubclass(d)
b = bidict(d)
f = frozenbidict(d)
n = namedbidict('named', 'keys', 'vals')(d)
dicts = (d, c, o, dd, s)
bidicts = (b, f, n)
@pytest.mark.parametrize('d, b', product(dicts, bidicts))
def test_eq(d, b):
assert d == b
yield Diagnostic(
Diagnostic.Messages.ARRAY_INDEX_WRONG_ORDER,
self.variable_name,
parseinfo=self.ast.parseinfo)
last_index = idx
def validate(self, lvalue=False):
if not self.variable:
yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_DECLARED,
self.variable_name,
parseinfo=self.ast.parseinfo)
elif self.variable not in self.context.initialized_variables and not lvalue:
yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_INITIALIZED,
self.variable.name,
parseinfo=self.ast.parseinfo)
elif isinstance(self.variable.value_type, ArrayType):
if self.variable not in self.context.allocated_variables_mapping:
yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_ALLOCATED,
self.variable.name,
parseinfo=self.ast.parseinfo)
for index in self.indices:
yield from index.validate()
if lvalue:
yield from self.validate_array_indexes()
expression_classes = frozenbidict({
"int_literal": IntLiteralExpression,
"reference": ReferenceExpression,
})
class ImageDataGeneration:
"""It has functionality to create generators to feed data to keras.
"""
valid_subsets = frozenbidict({
'training': ImageDataSubset.Training,
'validation': ImageDataSubset.Validation,
'prediction': ImageDataSubset.Prediction
})
def __init__(self,
dataframe,
input_params,
image_generation_params,
transformer=None,
randomize=True):
"""It initializes the dataframe object.
Arguments:
dataframe {Pandas DataFrame} -- A pandas dataframe object with columnar data with image names and labels.
input_params {A InputDataParameter object} -- An input parameter object.
image_generation_params {A ImageGenerationParameters object} -- A training data parameter object.
transformer {A ImageDataTransformation object} -- It is used to transform the image objects.
randomize {boolean} -- It indicates randomization of the input dataframe.
"""
#Required parameters
self._dataframe = dataframe
self._input_params = input_params
self._image_generation_params = image_generation_params
#Optional parameters
self._transformer = transformer
self._randomize = randomize
#Caching
self._image_cache = LRUCache(
self._image_generation_params.image_cache_size)
#Logging
self._logger = logging.get_logger(__name__)
#Metrics
self._load_slice_metric = 'get_image_objects'
#Create metrics
Metric.create(self._load_slice_metric)
#Compute the training and validation boundary using the validation split.
boundary = int(
ceil(
len(self._dataframe) *
(1. - self._image_generation_params.validation_split)))
self._logger.info(
"Validation split: {} Identified boundary: {}".format(
self._image_generation_params.validation_split, boundary))
#Split the dataframe into training and validation.
self._main_df = self._dataframe.loc[:(boundary - 1), :]
self._validation_df = self._dataframe.loc[boundary:, :].reset_index(
drop=True)
n_dataframe = len(self._dataframe)
n_main_df = len(self._main_df)
n_validation_df = len(self._validation_df)
self._logger.info(
"Dataframe size: {} main set size: {} validation size: {}".format(
n_dataframe, n_main_df, n_validation_df))
def _get_images(self, n_images):
"""It extracts the image names from the dataframe.
Arguments:
n_images {An numpy.array object} -- It is a 4-D numpy array containing image data.
"""
df_size = len(self._main_df)
loop_count = 0
images = set()
while len(images) <= n_images and loop_count < df_size:
random_index = randrange(df_size)
for image_col in self._image_generation_params.image_cols:
images.add(self._main_df.loc[random_index, image_col])
loop_count += 1
return list(images)
def fit(self, n_images):
"""It calculates statistics on the input dataset. These are used to perform transformation.
Arguments:
n_images {An numpy.array object} -- It is a 4-D numpy array containing image data.
"""
if n_images <= 0:
ValueError(
"Expected a positive integer for n_images. Got: {}".format(
n_images))
#Input list for data fitting
images = self._get_images(n_images)
self._logger.info("%d images to use for data fitting", len(images))
#Image objects
img_objs_map = self._get_image_objects(images)
img_objs = np.asarray(list(img_objs_map.values()))
self._logger.info(
"fit:: images: {} to the transformer to compute statistics".format(
img_objs.shape))
#Fit the data in the transformer
self._transformer.fit(img_objs)
def flow(self, subset='training'):
"""It creates an iterator to the input dataframe.
Arguments:
subset {string} -- A string to indicate select between training and validation splits.
"""
#Validate subset parameter
if not ImageDataGeneration.valid_subsets.get(subset):
raise ValueError("Valid values of subset are: {}".format(
list(ImageDataGeneration.valid_subsets.keys())))
#Qualified subset
q_subset = ImageDataGeneration.valid_subsets[subset]
#Dataframe placeholder
dataframe = None
#Pick the correct dataframe
if q_subset == ImageDataSubset.Training or q_subset == ImageDataSubset.Prediction:
dataframe = self._main_df
elif q_subset == ImageDataSubset.Validation:
dataframe = self._validation_df
self._logger.info("flow:: subset: {} dataset size: {}".format(
subset, len(dataframe)))
return ImageDataIterator(self,
dataframe,
self._image_generation_params.batch_size,
q_subset,
randomize=self._randomize)
def _load_subset_slice(self, df_slice, subset):
"""It loads the image objects and the labels for the data frame slice.
Arguments:
df_slice {A pandas.DataFrame object} -- A pandas DataFrame object containing input data and labels.
Returns:
{An object} -- A list of image objects in prediction phase. A tuple of image objects and their labels in training phase.
"""
self._logger.info('Using subset: %s', subset)
#Results placeholder
results = None
#Load the slice
if subset == ImageDataSubset.Training or subset == ImageDataSubset.Validation:
results = self._load_train_phase_slice(df_slice)
elif subset == ImageDataSubset.Prediction:
results = self._load_predict_phase_slice(df_slice)
return results
def _load_train_phase_slice(self, df_slice):
"""It loads the image objects and the labels for the data frame slice.
Arguments:
df_slice {A pandas.DataFrame object} -- A pandas DataFrame object containing input data and labels.
Returns:
(Numpy object, Numpy object) -- A tuple of input data and labels.
"""
return self._load_slice(df_slice)
def _load_predict_phase_slice(self, df_slice):
"""It loads the image objects for the data frame slice.
Arguments:
df_slice {A pandas.DataFrame object} -- A pandas DataFrame object containing input data and labels.
Returns:
(Numpy object, Numpy object) -- A tuple of input data and labels.
"""
images, _ = self._load_slice(df_slice)
return images
def _load_slice(self, df_slice):
"""It loads the image objects for the data frame slice.
Arguments:
df_slice {A pandas.DataFrame object} -- A pandas DataFrame object containing input data and labels.
Returns:
(Numpy object, Numpy object) -- A tuple of input data and labels.
"""
#Calculate the number of classes
num_classes = self._image_generation_params.num_classes
#Process labels
df_slice_y = df_slice[self._image_generation_params.label_col].values
df_slice_y_categorical = to_categorical(
df_slice_y,
num_classes=num_classes) if num_classes > 2 else df_slice_y
#Process image columns
df_slice_x = []
for x_col in self._image_generation_params.image_cols:
images = df_slice[x_col].tolist()
#Load images
img_objs_map = self._get_image_objects(images)
#Arrange them in the input order
img_objs = [img_objs_map[image] for image in images]
img_objs = np.asarray(img_objs)
if x_col in self._image_generation_params.image_transform_cols:
img_objs = self._apply_transformation(img_objs)
df_slice_x.append(img_objs)
return (df_slice_x, df_slice_y_categorical)
def _get_image_objects(self, images):
"""It loads the image objects for the list of images.
If the image is available, it is loaded from the cache.
Otherwise, it is loaded from the disk.
Arguments:
images {[string]} -- A list of image names.
"""
#Start recording time
record_handle = Metric.start(self._load_slice_metric)
img_objs = {}
candidate_images = set(images)
for image in candidate_images:
#Get the image object for the current image from the cache.
#Add to the dictionary, if it is not None.
img_obj = self._image_cache.get(image)
if img_obj is not None:
img_objs[image] = img_obj
#Create a list of missing images.
cached_images = set(img_objs.keys())
missing_images = [
image for image in candidate_images if not image in cached_images
]
self._logger.debug("Cached images: {} missing images: {}".format(
cached_images, missing_images))
#Load the missing image objects, and apply parameters.
missing_img_objs = utils.imload(
self._image_generation_params.dataset_location, missing_images,
self._image_generation_params.input_shape[:2])
missing_img_objs = self._apply_parameters(missing_img_objs)
#Update the cache
self._image_cache.update(zip(missing_images, missing_img_objs))
#Update the image object dictionary with the missing image objects.
for image, img_obj in zip(missing_images, missing_img_objs):
img_objs[image] = img_obj
#End recording time
Metric.stop(record_handle, self._load_slice_metric)
return img_objs
def _apply_parameters(self, img_objs):
"""It processes image objects based on the input parameters.
e.g. normalization, reshaping etc.
Arguments:
img_objs {numpy.ndarray} -- A numpy array of image objects.
"""
if self._image_generation_params.normalize:
img_objs = utils.normalize(img_objs)
return img_objs
def _apply_transformation(self, img_objs):
transformed_objects = img_objs
if self._transformer:
transformed_objects = self._transformer.transform(img_objs)
return transformed_objects
class _DictSubcls(dict):
pass
class _OrderedBidictSubcls(OrderedBidict):
pass
# pylint: disable=C0103
items = [('a', 1), ('b', 2)] # use int values so makes sense with Counter
itemsreversed = list(reversed(items))
bidict_of_items = bidict(items)
frozenbidict_of_items = frozenbidict(items)
namedbidict_of_items = namedbidict('named', 'keys', 'vals')(items)
orderedbidict_of_items = OrderedBidict(items)
orderedbidict_of_itemsreversed = OrderedBidict(itemsreversed)
orderedbidictsubcls_of_items = _OrderedBidictSubcls(items)
orderedbidictsubcls_of_itemsreversed = _OrderedBidictSubcls(itemsreversed)
frozenorderedbidict_of_items = FrozenOrderedBidict(items)
frozenorderedbidict_of_itemsreversed = FrozenOrderedBidict(itemsreversed)
bidicts = (
bidict_of_items,
frozenbidict_of_items,
namedbidict_of_items,
orderedbidict_of_items,
orderedbidict_of_itemsreversed,
orderedbidictsubcls_of_items,
orderedbidictsubcls_of_itemsreversed,
def test_frozenbidict_hash(d):
f = frozenbidict(d)
assert hash(f)
import string
from math import ceil
import bidict
SYMBOL_MAP = bidict.frozenbidict({
0: '.',
**{num: chr(64 + num)
for num in range(1, 25)},
**{
num: chr(110 + ceil(num / 24)) + chr(64 + (num % 24 or 24))
for num in range(25, 256)
}
})
SAFE_CHARS = string.ascii_lowercase + string.digits + string.punctuation.replace(
'.', '')
def maybe_double(symbol: str):
if len(symbol.encode()) < 2:
return symbol * 2
return symbol
class QuestionnaireImageWidget(QWidget):
number_key = frozenbidict({
0: QtCore.Qt.Key_0,
1: QtCore.Qt.Key_1,
2: QtCore.Qt.Key_2,
3: QtCore.Qt.Key_3,
4: QtCore.Qt.Key_4,
5: QtCore.Qt.Key_5,
6: QtCore.Qt.Key_6,
7: QtCore.Qt.Key_7,
8: QtCore.Qt.Key_8,
9: QtCore.Qt.Key_9
})
def __init__(self,
next_action=None,
finish_action=None,
previous_action=None,
back_action=None,
answer_action=None,
**kwargs):
super().__init__(**kwargs)
if next_action is None:
self.next_action = self.default_next
else:
self.next_action = next_action
if finish_action is None:
self.finish_action = self.default_finish
else:
self.finish_action = finish_action
if previous_action is None:
self.previous_action = self.default_previous
else:
self.previous_action = previous_action
if back_action is None:
self.back_action = self.default_back
else:
self.back_action = back_action
if answer_action is None:
self.answer_action = self.default_answer
else:
self.answer_action = answer_action
self.ui = Ui_EmotionQuestionnaireImage()
self.ui.setupUi(self)
self.ui.continueButton.clicked.connect(self._continue)
self.ui.backButton.clicked.connect(self.previous)
self.continueAction = QAction("Continue", self)
self.continueAction.setShortcut(QKeySequence("Shift+Return"))
self.continueAction.triggered.connect(self._continue)
self.addAction(self.continueAction)
self._path = None
self.text = None
self.qa = []
self.answers = []
self.answer_key = bidict()
self.q_index = 0
self.multi_answers = 1
self.current_question = None
self.current_answers = None
self.current_color = None
self.selected_answer = ""
@property
def path(self):
return self._path
@path.setter
def path(self, value):
if isinstance(value, pathlib.Path) or value is None:
self._path = value
else:
self._path = pathlib.Path(value)
def load_file(self, file):
if file is not None:
self.path = file
if self.path.as_posix() != '.':
q_file = toml.load(self.path)
self.qa = q_file['Questions']
self.q_index = 0
qa = self.qa[self.q_index]
self.set_color(qa['color'])
self.set_question(qa['question'])
self.set_answers(qa['answers'], qa['format'])
if 'image' in qa:
self.set_image(pathlib.Path(qa['image']))
def set_image(self, file):
if file is not None:
pixmap = QtGui.QPixmap(file.as_posix())
repixmap = pixmap.scaledToHeight(480)
self.ui.image.setPixmap(repixmap)
self.current_image = file
def set_color(self, color):
if color is not None:
self.ui.colorSpacer.setStyleSheet('background-color:rgb(' + color +
')')
self.current_color = color
def set_question(self, question):
self.ui.questionBrowser.setText(question)
self.current_question = question
def set_answers(self, answers, _format=None):
self.remove_answers()
self.current_answers = answers
if _format == 'scale':
size = (1, len(answers))
else:
size = (2, -(-len(answers) // 2))
b_size = (size[0] + 2, size[1] + 2)
topSpacer = QtWidgets.QSpacerItem(20, 5, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
bottomSpacer = QtWidgets.QSpacerItem(20, 5,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
leftSpacer = QtWidgets.QSpacerItem(5, 20, QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Minimum)
rightSpacer = QtWidgets.QSpacerItem(5, 20, QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Minimum)
self.ui.answersLayout.addItem(topSpacer, 0, 0, 1, b_size[1])
self.ui.answersLayout.addItem(bottomSpacer, b_size[1], 0, 1, b_size[1])
self.ui.answersLayout.addItem(leftSpacer, 1, 0, size[1], 1)
self.ui.answersLayout.addItem(rightSpacer, 1, size[1] + 1, size[1], 1)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
font = QtGui.QFont()
font.setPointSize(18)
self.ui.answerChecks = []
for i in range(0, size[0]):
for j in range(0, size[1]):
a_index = i * size[1] + j
if a_index < len(answers):
answer_check = QtWidgets.QCheckBox(self.ui.answersBox)
sizePolicy.setHeightForWidth(
answer_check.sizePolicy().hasHeightForWidth())
answer_check.setSizePolicy(sizePolicy)
answer_check.setFont(font)
answer_check.setObjectName('answer_check_' + str(a_index))
answer_check.setText(
QtWidgets.QApplication.translate(
"EmotionQuestionnaire", answers[a_index], None,
-1))
answer_check.clicked.connect(
self.generate_answer_function(answer_check))
self.ui.answerChecks.append(answer_check)
self.ui.answersLayout.addWidget(answer_check, i + 1, j + 1,
1, 1)
self.answer_key[answers[a_index]] = answer_check
def remove_answers(self):
self.answer_key.clear()
while not self.ui.answersLayout.isEmpty():
item = self.ui.answersLayout.takeAt(0)
if not item.isEmpty():
widget = item.widget()
widget.deleteLater()
del widget
self.ui.answersLayout.removeItem(item)
def generate_answer_function(self, answer_check):
return lambda v: self.answer_toggle(answer_check, v)
def answer_toggle(self, answer_check, value):
self.answer(answer_check, value)
if self.multi_answers > 0:
self.limit_answer(self.multi_answers, answer_check)
def answer(self, check_widget, value):
answer = self.answer_key.inverse[check_widget]
if answer is None:
answer = ""
self.selected_answer = answer
event = {
'type_': 'Questionnaire_AnswerSelected',
'File': self.path.name,
'Question': self.current_question,
'Answer': answer,
'Value': value
}
self.answer_action(event=event, caller=self)
def limit_answer(self, limit, last):
available = limit
other_answers = self.answer_key.copy()
other_answers.inverse.pop(last)
for answer in other_answers.values():
if answer.isChecked():
if available > 1:
available -= 1
else:
answer.setChecked(False)
def default_answer(self, event=None, caller=None):
pass
def keyPressEvent(self, event):
key = event.key()
if key in self.number_key.inverse:
number = self.number_key.inverse[key]
if number < len(self.current_answers):
check_widget = self.answer_key[self.current_answers[number]]
check_widget.setChecked(True)
self.answer_toggle(check_widget, True)
elif key == QtCore.Qt.Key_Enter or key == QtCore.Qt.Key_Return:
self._continue()
elif key == QtCore.Qt.Key_Backspace:
self.previous()
event.accept()
def _continue(self):
self.q_index += 1
event = {
'type_': 'Questionnaire_AnswerConfirmed',
'File': self.path.name,
'Question': self.current_question,
'Answer': self.selected_answer
}
if self.q_index < len(self.qa):
self.next_action(event=event, caller=self)
else:
self.finish_action(event=event, caller=self)
def default_next(self, event=None, caller=None):
if self.q_index < len(self.qa) - 1:
self.ui.continueButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Next", None, -1))
self.ui.backButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Previous", None, -1))
else:
self.ui.continueButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Done", None, -1))
self.ui.backButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Previous", None, -1))
qa = self.qa[self.q_index]
self.set_color(qa['color'])
self.set_question(qa['question'])
self.set_answers(qa['answers'], qa['format'])
if 'image' in qa:
self.set_image(pathlib.Path(qa['image']))
def default_finish(self, event=None, caller=None):
print("Not Connected")
def previous(self):
if self.q_index > 0:
self.q_index -= 1
event = {
'type_': 'Questionnaire_AnswerRetracted',
'File': self.path.name,
'Question': self.qa[self.q_index]['question']
}
self.previous_action(event=event, caller=self)
else:
event = {'type_': 'Questionnaire_Exited', 'File': self.path.name}
self.back_action(event=event, caller=self)
def default_previous(self, event=None, caller=None):
if self.q_index > 0:
self.ui.continueButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Next", None, -1))
self.ui.backButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Previous", None, -1))
else:
self.ui.continueButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Next", None, -1))
self.ui.backButton.setText(
QtWidgets.QApplication.translate("EmotionQuestionnaire",
"Exit", None, -1))
qa = self.qa[self.q_index]
self.set_color(qa['color'])
self.set_question(qa['question'])
self.set_answers(qa['answers'], qa['format'])
if 'image' in qa:
self.set_image(pathlib.Path(qa['image']))
def default_back(self, event=None, caller=None):
print('There is no going back')
from telegram.ext import Updater, Dispatcher, Filters, CommandHandler, MessageHandler
import config
from lib import locale, chart_maker, currencymap
from lib.exchange_api import ExchangeError
from lib.exchange_api.cache_wrapper import CacheWrapper
from lib.exchange_api.exchangeratesapi_io import ExchangeRatesAPIio
# enable logging
logging.basicConfig(format='[%(asctime)s|%(name)s|%(levelname)s] %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
symbol_code_map = bidict.frozenbidict({
curr_info['symbol']: curr_code
for curr_code, curr_info in currencymap.get().items()
if len(curr_info['symbol']) == 1 # only symbols
})
# init api
exchange_api = ExchangeRatesAPIio()
# == WARN ZONE ==
# i don't have enough time to write this in right way(
# get cache backend
if config.IS_LOCAL:
import cachetools
cache_backend = cachetools.TTLCache(64, ttl=config.CACHE_TTL_SECONDS)
else:
label_names = set(input_data_df[label_col].tolist())
label_names_size = len(label_names)
logger.info('Loaded %d label names', label_names_size)
#Generate label classes
label_classes = list(range(len(label_names)))
label_classes_size = len(label_classes)
logger.info('Created %d label classes', label_classes_size)
#Output dataframe
output_df = DataFrame(columns=list(input_data_df))
print(list(input_data_df))
#Create names to class mappings
mappings = frozenbidict(zip(label_names, label_classes))
for _, row in input_data_df.iterrows():
label_name = row[label_col]
label_class = mappings[label_name]
#Update the row
row[label_col] = label_class
#Save the updated dataframe
input_data_df.to_csv(input_data)
#Save mappings
with mapping_keys.open(mode='wb') as handle:
pickle_dump(mappings, handle)
frozenbidict(
{
'album': 'TAL',
'albumsort': 'TSA',
'albumartist': 'TP2',
'albumartistsort': 'TS2',
'artist': 'TP1',
'artistsort': 'TSP',
'audiodelay': 'TDY',
'audiolength': 'TLE',
'audiosize': 'TSI',
'bpm': 'TBP',
'comment': 'COM',
'compilation': 'TCP',
'composer': 'TCM',
'composersort': 'TSC',
'conductor': 'TP3',
'copyright': 'TCR',
'date': 'TYE',
'discnumber': 'TPA',
'encodedby': 'TEN',
'encodersettings': 'TSS',
'genre': 'TCO',
'grouping': 'TT1',
'isrc': 'TRC',
'key': 'TKE',
'label': 'TPB',
'language': 'TLA',
'license': 'WCP',
'lyricist': 'TXT',
'lyrics': 'ULT',
'media': 'TMT',
'originalalbum': 'TOT',
'originalartist': 'TOA',
'originaldate': 'TOR',
'originalfilename': 'TOF',
'originallyricist': 'TOL',
'people': 'IPL',
'pictures': 'PIC',
'playcount': 'CNT',
'rating': 'POP',
'remixer': 'TP4',
'subtitle': 'TT3',
'tempo': 'STC',
'title': 'TT2',
'titlesort': 'TST',
'tracknumber': 'TRK',
'ufid': 'UFI',
'usertext': 'TXX',
'userurl': 'WXX',
}, ),
import pytest
from collections import Counter, OrderedDict, defaultdict
from bidict import bidict, frozenbidict, namedbidict
from itertools import product
d = dict(H='hydrogen', He='helium')
c = Counter(d)
o = OrderedDict(d)
dd = defaultdict(int, d)
class dictsubclass(dict): pass
s = dictsubclass(d)
b = bidict(d)
f = frozenbidict(d)
n = namedbidict('named', 'keys', 'vals')(d)
dicts = (d, c, o, dd, s)
bidicts = (b, f, n)
@pytest.mark.parametrize('d, b', product(dicts, bidicts))
def test_eq(d, b):
assert d == b
class ID3v2Frames(Tags):
_v22_FIELD_MAP = frozenbidict({
'album': 'TAL',
'albumartist': 'TP2',
'arranger': 'TP4',
'artist': 'TP1',
'audiodelay': 'TDY',
'audiolength': 'TLE',
'audiosize': 'TSI',
'bpm': 'TBP',
'comment': 'COM',
'composer': 'TCM',
'conductor': 'TP3',
'copyright': 'TCR',
'date': 'TYE',
'discnumber': 'TPA',
'encodedby': 'TEN',
'encodingsettings': 'TSS',
'genre': 'TCO',
'grouping': 'TT1',
'isrc': 'TRC',
'language': 'TLA',
'lyricist': 'TXT',
'lyrics': 'ULT',
'media': 'TMT',
'originalalbum': 'TOT',
'originalartist': 'TOA',
'originalauthor': 'TOL',
'originalyear': 'TOR',
'pictures': 'PIC',
'playcount': 'CNT',
'publisher': 'TPB',
'subtitle': 'TT3',
'title': 'TT2',
'tracknumber': 'TRK'
})
_v23_FIELD_MAP = frozenbidict({
'album': 'TALB',
'albumsort': 'TSOA',
'albumartist': 'TPE2',
'albumartistsort': 'TSO2',
'arranger': 'TPE4',
'artist': 'TPE1',
'artistsort': 'TSOP',
'audiodelay': 'TDLY',
'audiolength': 'TLEN',
'audiosize': 'TSIZ',
'bpm': 'TBPM',
'comment': 'COMM',
'compilation': 'TCMP',
'composer': 'TCOM',
'composersort': 'TSOC',
'conductor': 'TPE3',
'copyright': 'TCOP',
'date': 'TYER',
'discnumber': 'TPOS',
'encodedby': 'TENC',
'encodingsettings': 'TSSE',
'genre': 'TCON',
'grouping': 'TIT1',
'isrc': 'TSRC',
'language': 'TLAN',
'lyricist': 'TEXT',
'lyrics': 'USLT',
'media': 'TMED',
'originalalbum': 'TOAL',
'originalartist': 'TOPE',
'originalauthor': 'TOLY',
'originalyear': 'TORY',
'pictures': 'APIC',
'playcount': 'PCNT',
'publisher': 'TPUB',
'subtitle': 'TIT3',
'title': 'TIT2',
'titlesort': 'TSOT',
'tracknumber': 'TRCK'
})
_v24_FIELD_MAP = frozenbidict({
'album': 'TALB',
'albumsort': 'TSOA',
'albumartist': 'TPE2',
'albumartistsort': 'TSO2',
'arranger': 'TPE4',
'artist': 'TPE1',
'artistsort': 'TSOP',
'audiodelay': 'TDLY',
'audiolength': 'TLEN',
'audiosize': 'TSIZ',
'bpm': 'TBPM',
'comment': 'COMM',
'compilation': 'TCMP',
'composer': 'TCOM',
'composersort': 'TSOC',
'conductor': 'TPE3',
'copyright': 'TCOP',
'date': 'TDRC',
'discnumber': 'TPOS',
'encodedby': 'TENC',
'encodingsettings': 'TSSE',
'genre': 'TCON',
'grouping': 'TIT1',
'isrc': 'TSRC',
'language': 'TLAN',
'lyricist': 'TEXT',
'lyrics': 'USLT',
'media': 'TMED',
'mood': 'TMOO',
'originalalbum': 'TOAL',
'originalartist': 'TOPE',
'originalauthor': 'TOLY',
'originalyear': 'TORY',
'pictures': 'APIC',
'playcount': 'PCNT',
'publisher': 'TPUB',
'subtitle': 'TIT3',
'title': 'TIT2',
'titlesort': 'TSOT',
'tracknumber': 'TRCK'
})
@classmethod
def load(cls, data, id3_version):
if not isinstance(data, DataReader): # pragma: nocover
data = DataReader(data)
if id3_version is ID3Version.v22:
cls.FIELD_MAP = cls._v22_FIELD_MAP
struct_pattern = '3s3B'
size_len = 3
per_byte = 8
elif id3_version is ID3Version.v23:
cls.FIELD_MAP = cls._v23_FIELD_MAP
struct_pattern = '4s4B2B'
size_len = 4
per_byte = 8
elif id3_version is ID3Version.v24:
cls.FIELD_MAP = cls._v24_FIELD_MAP
struct_pattern = '4s4B2B'
size_len = 4
per_byte = 7
else:
raise ValueError(f"Unsupported ID3 version: {id3_version}")
frames = defaultdict(list)
while True:
try:
frame = ID3v2Frame.load(data, struct_pattern, size_len,
per_byte)
except InvalidFrame:
break
# Ignore oddities/bad frames.
if not isinstance(frame, ID3v2BaseFrame):
continue
# TODO: Finish any missing frame types.
# TODO: Move representation into frame classes?
if isinstance(frame,
(ID3v2CommentFrame, ID3v2SynchronizedLyricsFrame,
ID3v2UnsynchronizedLyricsFrame)):
frames[
f'{frame.id}:{frame.description}:{frame.language}'].append(
frame.value)
elif isinstance(frame, ID3v2GenreFrame):
frames['TCON'] = frame.value
elif isinstance(frame, ID3v2GEOBFrame):
frames[f'GEOB:{frame.description}'].append({
'filename': frame.filename,
'mime_type': frame.mime_type,
'value': frame.value
})
elif isinstance(frame, ID3v2PrivateFrame):
frames[f'PRIV:{frame.owner}'].append(frame.value)
elif isinstance(frame,
(ID3v2UserTextFrame, ID3v2UserURLLinkFrame)):
frames[f'{frame.id}:{frame.description}'].append(frame.value)
elif isinstance(
frame,
(ID3v2NumericTextFrame, ID3v2TextFrame, ID3v2TimestampFrame)):
frames[frame.id] = frame.value
else:
frames[frame.id].append(frame.value)
return cls(frames)
def _build_category_ref_bidict(self, category_lines):
return frozenbidict({ int(cat[0]):cat[1] for cat in category_lines })
def __init__(
self,
use_single_note_off_event: bool = False,
use_end_of_sequence_event: bool = False,
encode_velocity: bool = False,
force_velocity_event: bool = True,
max_time_shift: int = 100,
velocity_bins: int = 32,
default_velocity: int = 64,
encode_instrument: bool = False,
default_program: int = 0,
default_is_drum: bool = False,
num_tracks: Optional[int] = None,
ignore_empty_tracks: bool = False,
resolution: int = DEFAULT_RESOLUTION,
duplicate_note_mode: str = "fifo",
timing: "Optional[Timing]" = None,
):
self.use_single_note_off_event = use_single_note_off_event
self.use_end_of_sequence_event = use_end_of_sequence_event
self.encode_velocity = encode_velocity
self.force_velocity_event = force_velocity_event
self.velocity_bins = velocity_bins
self.default_velocity = default_velocity
self.encode_instrument = encode_instrument
self.default_program = default_program
self.default_is_drum = default_is_drum
self.num_tracks = num_tracks
self.ignore_empty_tracks = ignore_empty_tracks
self.resolution = resolution
self.duplicate_note_mode = duplicate_note_mode
self.timing = timing
if self.timing is None:
self.timing = TickShiftTiming(max_shift=max_time_shift)
if encode_instrument and num_tracks is None:
raise ValueError(
'Cannot encode instruments when num_tracks is None')
# Create vocabulary of events
vocab_list = [] # type: list
track_ids = [0] if num_tracks is None else range(num_tracks)
vocab_list.extend(
(NOTE_ON, tr, i) for tr in track_ids for i in range(128))
vocab_list.extend((NOTE_OFF, tr, i) for tr in track_ids for i in (
[ALL_NOTES] if use_single_note_off_event else range(128)))
vocab_list.extend(self.timing.vocab_list)
if encode_velocity or num_tracks is None:
# In single-track mode, always include velocity tokens
# for backwards compatibility
vocab_list.extend((VELOCITY, tr, v) for tr in track_ids
for v in range(velocity_bins))
if encode_instrument:
vocab_list.extend(
(PROGRAM, tr, pr) for tr in track_ids for pr in range(128))
vocab_list.extend((DRUM, tr) for tr in track_ids)
if use_end_of_sequence_event:
vocab_list.append((EOS, ))
# Map human-readable tuples to integers
self.vocab = frozenbidict(
enumerate(vocab_list)).inverse # type: frozenbidict[Any, int]
