def best_accuracy_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.best_accuracies:
note_range = self.get_range_for(note)
peaks_to_check = [
index for index in self.peaks if index in note_range
]
if len(peaks_to_check) == 0:
self.best_accuracies[str(note)] = 50
else:
self.best_accuracies[str(note)] = np.min([
np.abs(Note(self.xf[i]).accuracy) for i in peaks_to_check
])
return self.best_accuracies[str(note)]
def select_note(self, min_increase=0.2, n=4, accuracy=30):
if not hasattr(self, 'notes'):
self.notes = []
if not hasattr(self, 'explained_percent'):
self.explained_percent = 0
if not hasattr(self, 'frequency_ranges'):
self.frequency_ranges = []
best_value = 0
best_note = 'E2'
for key in self.note_integrals:
if self.note_integrals[key] > best_value:
best_value = self.note_integrals[key]
best_note = key
value_increase = best_value - self.explained_percent
if value_increase > min_increase:
print(best_note)
print(best_value)
best_note = Note(best_note)
self.notes.append(best_note)
self.explained_percent = best_value
return value_increase
else:
return 0
def average_intensity_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.average_intensities:
self.average_intensities[str(note)] = np.mean(
[self.fft_out[i] for i in self.get_range_for(note)])
return self.average_intensities[str(note)]
def get_member_notes(member: discord.Member,
guild: discord.Guild) -> [Note] or None:
""" Get a guild members notes. Usually called after !notes is invoked in a guild
Args:
member (discord.Member): The member retrieving their notes
guild (discord.Guild): The guild that the notes are attached to
Returns:
[Note or None]: The Notes that the user has saved, loaded into Note's
"""
try:
db_coll = db.get_collection(str(guild.id))
except Exception:
logger.exception("No guild ID given")
return
res = db_coll.find_one({"user_id": member.id})
if not res:
return None
else:
notes = [Note(details) for details in res["notes"]]
return notes
def on_action_new_note_triggered(self):
'''
..todo: Add multi account support - Select target account for new notes
'''
if self.list_widget_notelist.currentRow() >= 0 and\
(self.line_edit_subject.isModified() or self.text_edit_editor.document().isModified()):
self.on_action_save_note_triggered()
note = Note(account_id=self._account_manager.get_account(
self._account_manager.list_accounts()[0]).id,
title='New Note')
if not self.list_widget_notelist.currentItem(
) and self.list_widget_notelist.count() <= 0:
if self.line_edit_subject.isModified() and len(
self.line_edit_subject.text().strip()) > 0:
note.title = self.line_edit_subject.text()
if self.text_edit_editor.document().isModified() and len(
self.text_edit_editor.document().toPlainText().strip(
)) > 0:
note.html_content = self.text_edit_editor.document().toHtml()
note.create()
self.__load_note_to_list(note.account_id, note.file)
self.list_widget_notelist.setCurrentRow(0)
def post(self):
#geting data from fron-end
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
data, errors = note_schema.load(json_data)
if errors:
return errors, 422
user_id = get_jwt_identity()
notebook = Notebook.query.filter_by(id=data['notebook_id']).first()
if not notebook:
return {'message': 'Category does not exist'}, 400
notebook.modified_date = datetime.now(pytz.utc)
#matching new note data by fields
new_note = Note(title=data['title'],
body=data['body'],
creation_date=datetime.now(pytz.utc),
modified_date=datetime.now(pytz.utc),
notebook_id=data['notebook_id'],
user_id=user_id)
#submitting note to database
db.session.add(new_note)
db.session.commit()
#get json from pyton object
result = note_schema.dump(new_note).data
return {"status": 'success', 'data': result}, 201
class Notes:
__note = Note()
__today = datetime.date(datetime.now())
def getAll(self, order_by='id', order_method='DESC'):
notes_data = self.__note.find('id', '>', '0', order_by, order_method)
notes = []
for note in notes_data:
if parse(note['time']).date() == self.__today:
note['time'] = datetime.strptime(
note['time'], "%Y-%j-%d %H:%M:%S").strftime('%I:%M %p')
notes.append(note)
return notes
def create(self, title, time):
time = parse(time)
note = {
'title': title,
'time': time,
}
id = self.__note.create(note)
note['id'] = id
from libs.alarm import notes
notes.append(note)
def delete(self, id):
self.__note.delete({'key': 'id', 'value': id})
from libs.alarm import notes
for i in range(len(notes)):
if notes[i]['id'] == int(id):
del notes[i]
break
def draw_note(self, note, labelfunc=str, octaves=True, color='k'):
note = Note(note)
frets = self.find_note(note, octaves=octaves)
if octaves:
accuracy = int(np.round(note.accuracy))
if accuracy > 0:
label = "%s + %.0f" % (note.note, accuracy)
elif accuracy < 0:
label = "%s %.0f" % (note.note, accuracy)
else:
label = note.note
else:
label = str(note)
X = []
Y = []
for fret in frets:
plt.text(fret.xpos,
fret.ypos,
labelfunc(fret),
horizontalalignment='center',
verticalalignment='center',
fontsize=12)
X.append(fret.xpos)
Y.append(fret.ypos)
plt.scatter(X,
Y,
s=300,
linewidth=2,
label=label,
facecolors='white',
edgecolors=color)
async def add(self, message: discord.Message, params: list):
"""
Adds a note to the database using the provided parameters.
:param message: Instance of the discord message that triggered the error. (discord.Message)
:param params: Message parameters/note attributes. (List[String])
"""
if len(params) != 5:
await self.error(message, 'Add command takes exactly 3 parameters!')
return
title = params[2]
body = params[3]
tags = params[4].split(',')
note = Note(
title=title,
body=body,
tags=tags,
author=message.author.name
)
try:
note = self.note_repository.create(note)
except Exception as e:
await self.error(message, str(e))
return
response = note.to_json()
await message.author.send(response)
def __init__(self, data, max_fret=18, index=0):
if isinstance(data, String):
self.root = data.root
else:
self.root = Note(data)
self.max_fret = max_fret
self.index = index
def get_accuracy(self, note):
if not hasattr(self, 'root'):
return 0
note = Note(note)
accuracy = (note / self.root) % 1
return np.min([accuracy, 1 - accuracy])
def add_notes(self, notes_dicts):
for note_dict in notes_dicts:
note = None
if note_dict.has_key('id'):
notes = filter(lambda x: x.id == note_dict['id'], self.notes)
if len(notes) > 0:
note = notes[0]
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
note.text = note_dict['text']
db.session.commit()
def get_range_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.ranges:
start = self.get_index_of_frequency((note - .5).frequency)
end = self.get_index_of_frequency((note + .5).frequency)
self.ranges[str(note)] = range(start, end)
return self.ranges[str(note)]
def get_value(self, index):
frequency = self.parent.xf[index]
# below 10 hz we honestly don't care and the pitch of the note is hard to identify
if frequency < 10:
return 0
return np.abs(Note(frequency).accuracy)
def create_note(self, data, **kwargs):
data.update({
'created_at': datetime.now().date(),
'edited_at': datetime.now().date(),
'created_by': "Cristhian"
})
return Note(**data)
def annotate_peaks(self):
if not hasattr(self, 'peaks'):
self.find_peaks()
for index in self.peaks:
intensity = self.fft_out[index]
frequency = self.xf[index]
note = Note(frequency)
plt.text(frequency, intensity, str(note), fontsize=8, clip_on=True)
def find_notes(self):
if not hasattr(self, 'peaks'):
self.find_peaks()
self.notes = []
for index in self.peaks:
if all(map(lambda f: f.is_valid(index), self.note_filters)):
self.notes.append(Note(self.xf[index]))
return self.notes
def load(path):
file = open(path, 'r')
position_dict = '①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟㊱㊲㊳㊴㊵㊶㊷㊸㊹㊺㊻㊼㊽㊾㊿口'
arrow_dict = '∧Ｖ＜＞'
time_dict = '|－'
dicts = position_dict + arrow_dict + time_dict
lines = [
line for line in
[re.sub('[^%s]' % dicts, '', line) for line in file.readlines()]
if len(line) > 0
]
coordinate_time_tuples = [
CoordinateTimeTuple(line[:4], re.sub('[%s]' % '|', '', line[4:]))
for line in lines
]
times = []
coordinates = []
measures = []
for coordinate_time_tuple in coordinate_time_tuples:
coordinates.append(coordinate_time_tuple.coordinate)
if len(coordinate_time_tuple.time) > 0:
times.append(coordinate_time_tuple.time)
if len(times) >= 4 and len(''.join(coordinates)) % 16 == 0:
coordinate = ''.join(times).replace('－', '')
time_dict = ''.join(coordinates).replace('口', '')
diff = coordinate.translate(str.maketrans('', '', time_dict))
if len(diff) <= 0:
measures.append([''.join(list(coordinates)), list(times)])
del times[:]
del coordinates[:]
offset = 80 # ms
total_time = offset
bpm = 200
notes = []
for i, measure in enumerate(measures):
coordinates = measure[0]
times = measure[1]
for time in times:
for c in time:
split_size = len(time)
total_time += 60000.0 / bpm / split_size # TODO 口⑤口口 |④－| の表記の対処法
if c == '－':
continue
notes.append(
Note(c, total_time,
[(i % 16) + 1
for i, x in enumerate(coordinates) if x == c], bpm))
return notes, offset
def CreateNote(notes_filename, section_id):
date_added = datetime.now()
new_note = Note(notes_filename=notes_filename,
section_id=section_id,
date_added=date_added)
db.session.add(new_note)
db.session.commit()
return new_note.id
def create_note_impl(args):
try:
validate(args)
note = Note(
user_book_from_book_id(args["book_id"],
user_by_user_id(args['user_id']).id),
args['text'])
db.session.add(note)
db.session.commit()
return Response(True, "", NoteSchema().dumps(note).data).output()
except Exception, e:
return Response(False, str(e), None).output()
def __init__(self, key, progression_type='major'):
self.key = key
self.root = Note(key)
self.note_order = self.blueprints[progression_type.lower()]
self.title = progression_type.replace('-',' ').title()
self.name = "%s %s" % (self.key, self.title)
self.notes = []
self.overtone_range_cache = {}
for scale_number in self.note_order:
halfsteps = ScaleNotes.index(scale_number)
note = self.root + halfsteps
self.notes.append(note)
def overtone_ranges(self, n, accuracy):
key = "%d%f" % (n, accuracy)
if not key in self.overtone_range_cache:
ranges = []
for note in self.notes:
low_note = Note(note)
low_note.set_octave(2)
ranges += low_note.overtone_ranges(n, accuracy)
self.overtone_range_cache[key] = FrequencyRange.simplify(ranges)
return self.overtone_range_cache[key]
def note_save():
user_token = auth_verify(dict(request.headers))
body = request.json
body.update({"owner_id": user_token["id"]})
validated = NoteSchema().load(body)
if validated.errors:
abort(400, validated.errors)
noteData = Note(**validated.data)
noteData.save()
return parse_response(validated.data)
def select(note_id):
# Create the SQL query, pass in the data and run it
sql = "SELECT * FROM note WHERE id = %s"
values = [note_id]
result = run_sql(sql, values)
# Create object if data is found in the database
if len(result) > 0:
pet = PR.select(result[0]['pet_id'])
vet = VR.select(result[0]['vet_id'])
new_note = Note(result[0]['date'], result[0]['note_text'], pet, vet)
return new_note
def set_note_axes(self):
plt.grid(True, which='major', axis='x')
plt.grid(True, linestyle='--', which='minor', axis='x')
major_tick_notes = Note.range(Note('E2'), Note('E7'), step=12)
minor_tick_notes = list(
filter(lambda n: n.note != 'E',
Note.range(Note('E2'), Note('E7'), step=1)))
ax = plt.gca()
ax.set_xticks(list(map(lambda n: n.frequency, minor_tick_notes)),
minor=True)
ax.set_xticklabels(list(map(str, minor_tick_notes)),
fontsize=5,
rotation=90,
minor=True)
ax.set_xticks(list(map(lambda n: n.frequency, major_tick_notes)),
minor=False)
ax.set_xticklabels(list(map(str, major_tick_notes)),
fontsize=10,
rotation=90,
minor=False)
def on_action_duplicate_note_triggered(self):
if self.line_edit_subject.isModified(
) or self.text_edit_editor.document().isModified():
self.on_action_save_note_triggered()
note = Note(account_id=self._account_manager.get_account(
self._account_manager.list_accounts()[0]).id,
title='{} (Copy)'.format(self.line_edit_subject.text()),
html_content=self.text_edit_editor.toHtml())
note.create()
self.__load_note_to_list(note.account_id, note.file)
self.list_widget_notelist.setCurrentRow(0)
def save_note(id):
note_date = request.form['note_date']
note_text = request.form['note_text']
vet_id = request.form['note_vet']
# Grab the data for the object
pet = PR.select(id)
vet = VR.select(vet_id)
# Create the note object for saving
note = Note(note_date, note_text, pet, vet)
NR.save(note)
# Redirect
return redirect('/pets/' + id)
def create_note():
if not request.json:
return jsonify({'error': 'Empty request'})
elif not all(key in request.json
for key in ['name', 'text', 'author_id', 'is_private']):
return jsonify({'error': 'Bad request'})
db_sess = db_session.create_session()
note = Note(
name=request.json['name'],
text=request.json['text'],
author_id=request.json['author_id'],
is_private=request.json['is_private'],
)
db_sess.add(note)
db_sess.commit()
return jsonify({'success': 'OK'})
class TestNote(TestCase):
_item = Item()
_note = Note()
_db = SqlitePersistence(":memory:")
def setUp(self):
self._item.rig = "X01"
self._item.description = "Something to handover"
self._item.case = "CAS-12345"
self._db.save(self._item)
self._note.description = "Some update"
self._note.item_id = 1
self._db.save(self._note)
def test_a_note_has_a_description(self):
note = self._db.find(Note, 1)
self.assertEqual(note.description, "Some update")
def test_a_note_has_an_item(self):
note = self._db.find(Note, 1)
self.assertEqual(note.item.description, self._item.description)
def test_a_saved_note_has_a_created_by_timestamp(self):
note = self._db.find(Note, 1)
self.assertIsNotNone(note.created_by)
def test_a_saved_note_has_an_updated_by_timestamp(self):
note = self._db.find(Note, 1)
self.assertIsNotNone(note.updated_by)
def test_a_saved_note_has_a_created_by(self):
note = self._db.find(Note, 1)
self.assertEqual(note.created_by, os.getlogin())
def test_a_saved_note_has_an_updated_by(self):
note = self._db.find(Note, 1)
self.assertEqual(note.updated_by, os.getlogin())
def test_a_note_can_be_edited(self):
note = self._db.find(Note, 1)
data = {"description": "a note"}
self._db.edit(Note, note.id, data)
edited = self._db.find(Note, note.id)
self.assertEqual(data["description"], edited.description)
def __load_note_to_list(self,
account_id: str,
file: str,
refresh_list: bool = True):
logger.debug(
'(Re)loading note from account {} to the note list: {}'.format(
account_id, file))
list_item = None
list_item_widget = None
list = self.list_widget_notelist.findItems(file, Qt.MatchExactly)
if len(list) == 1:
list_item = list[0]
list_item_widget = self.list_widget_notelist.itemWidget(list_item)
elif len(list) > 1:
logger.warning(
'Found multiple widgets for filename \'{}\''.format(file))
return
if not list_item or not list_item.text() or len(list_item.text()) <= 0:
list_item_widget = NotesListWidgetItemWidget(
filename=file, checksum=Util.calculate_file_checksum(file))
list_item = SortableListWidgetItem(
Note(account_id=account_id, file=file))
list_item.setSizeHint(
QSize(self.list_widget_notelist.width(),
list_item_widget.height()))
list_item.setFont(QFont())
self.list_widget_notelist.addItem(list_item)
self.list_widget_notelist.setItemWidget(list_item,
list_item_widget)
list_item_widget.set_title(list_item.note.title)
list_item_widget.set_preview_text(
list_item.note.document.toPlainText()[:Configuration().get_setting(
'oxnote',
'application.settings.preview_content_length_maximum',
default=200)])
list_item_widget.set_icon(list_item.note.note_list_preview_image)
list_item.setText(file)
if refresh_list:
self.__refresh_notes_list()
