def extract_target_slug(self):
if '@target' in self.link_dict and '@lemma' in self.link_dict:
return slugify(self.link_dict['@lemma']) + '#' + self.link_dict['@target']
elif '@prefLabel' in self.link_dict:
return slugify(self.link_dict['@prefLabel'])
else:
return slugify(self.link_dict['#text'])
def __init__(self, entity):
self.entity = entity
self.name = self.entity['#text']
self.slug = slugify(self.name)
self.entity_type = self.entity['@type']
self.pref_label = self.extract_pref_label()
self.pref_label_slug = slugify(self.pref_label)
self.entity_object = self.add_to_db()
self.update_entity_object()
def __init__(self, rhyme_dict):
self.rhyme_dict = rhyme_dict
self.word_one = self.rhyme_dict['#text']
self.word_one_slug = slugify(self.word_one)
self.word_one_position = self.rhyme_dict['@position']
self.word_two = self.rhyme_dict['@rhymeTargetWord']
self.word_two_position = self.rhyme_dict['@rhymeTargetPosition']
self.word_two_slug = slugify(self.word_two)
self.word_two_target_id = self.extract_target_id()
self.rhyme_object = self.add_to_db()
self.update_rhyme_object()
def process_row(row):
xml_id, artist, album, \
release_date, song_title, \
feat, lyrics, discogs_date, \
rel_date_verified, lyrics_verified = row
song_object, created = get_song(xml_id)
if created or song_object.slug is None:
if release_date == 0:
release_date = "0001-01-01"
song_object.release_date = clean_up_date(str(release_date))
song_object.release_date_string = str(release_date)
artist_object = get_artist(artist)
song_object.artist_name = artist_object.name
song_object.artist_slug = artist_object.slug
song_object.artist.add(artist_object)
artist_object.primary_songs.add(song_object)
if feat:
feat_artists = [get_artist(f) for f in feat.split('; ')]
[song_object.feat_artist.add(f) for f in feat_artists]
[feat_object.featured_songs.add(song_object) for feat_object in feat_artists]
song_object.title = song_title
song_object.album = album
song_object.slug = slugify(song_object.artist_name + ' ' + song_title)
song_object.lyrics = lyrics
if rel_date_verified == 'MBK':
song_object.release_date_verified = True
else:
song_object.release_date_verified = False
song_object.save()
print('Processed', xml_id, artist, '- "' + song_title + '"')
def __init__(self, sense_object, example_dict):
self.sense_object = sense_object
self.example_dict = example_dict
self.song_title = self.example_dict['songTitle']
self.xml_id = self.example_dict['@id']
self.release_date_string = self.example_dict['date']
self.release_date = clean_up_date(self.release_date_string)
self.album = self.example_dict['album']
self.artist_name = self.get_artist_name()
self.artist_slug = slugify(self.artist_name)
self.lyric_text = self.example_dict['lyric']['text']
self.example_object = self.add_to_db()
# self.remove_previous_lyric_links_and_rhymes()
self.lyric_links = []
self.example_rhymes = []
self.extract_rf()
self.entities = []
self.xrefs = []
self.extract_entities()
self.extract_rhymes()
self.update_example()
self.primary_artists = self.get_primary_artists()
self.featured_artists = self.get_featured_artists()
self.extract_xrefs()
self.song = TRRSong(self.xml_id, self.release_date, self.release_date_string,
self.song_title, self.artist_name, self.artist_slug,
self.primary_artists, self.featured_artists, self.album)
self.add_relations()
def __init__(self, entry_object, headword, pos, sense_dict, publish):
self.parent_entry = entry_object
self.headword = headword
self.pos = pos
self.sense_dict = sense_dict
self.publish = publish
self.xml_id = self.sense_dict['@id']
self.slug = slugify(self.headword)
self.definition = self.extract_definition()
self.etymology = self.extract_etymology()
self.notes = self.extract_notes()
self.sense_object = self.add_to_db()
self.update_sense()
self.domains = []
self.extract_domains()
self.semantic_classes = []
self.extract_semantic_classes()
self.collocates = []
self.extract_collocates()
self.rhymes = []
self.extract_rhymes()
self.synset = []
self.extract_synset()
self.xrefs = []
self.extract_xrefs()
self.examples = [e for e in self.extract_examples()]
self.add_relations()
self.update_entry()
def get_artist(name):
slug = slugify(name)
artist_object, created = Artist.objects.get_or_create(slug=slug)
if not created or artist_object.name is None:
artist_object.name = name
artist_object.save()
return artist_object
def __init__(self, rhyme_dict, sense_id):
self.rhyme_dict = rhyme_dict
self.source_sense_xml_id = sense_id
self.rhyme = self.rhyme_dict['#text']
self.rhyme_slug = slugify(self.rhyme)
self.rhyme_object = self.add_to_db()
self.frequency = self.extract_frequency()
self.update_rhyme_object()
def __init__(self, name):
self.full_name = name
self.name = self.extract_short_name()
self.slug = slugify(self.full_name)
self.place_object = self.add_to_db()
self.update_place_object()
self.add_lat_long()
self.check_if_part()
def __init__(self, collocate_dict, sense_id):
self.collocate_dict = collocate_dict
self.source_sense_xml_id = sense_id
self.collocate_lemma = self.collocate_dict['#text']
self.target_id = self.collocate_dict['@target']
self.target_slug = slugify(self.collocate_lemma)
self.collocate_object = self.add_to_db()
self.frequency = self.extract_frequency()
self.update_collocate_object()
def __init__(self, xref_dict):
self.xref_dict = xref_dict
self.xref_word = self.xref_dict['#text']
self.xref_type = self.extract_xref_type()
self.target_id = self.xref_dict['@target']
self.target_lemma = self.extract_target_lemma()
self.target_slug = slugify(self.target_lemma)
self.xref_object = self.add_to_db()
self.position = self.extract_position()
self.frequency = self.extract_frequency()
self.update_xref_object()
def __init__(self, xml_id, release_date, release_date_string, song_title, artist_name, artist_slug, primary_artists, feat_artists, album):
self.xml_id = xml_id
self.release_date = release_date
self.release_date_string = release_date_string
self.title = song_title
self.artist_name = artist_name
self.artist_slug = artist_slug
self.slug = slugify(self.artist_name + ' ' + self.title)
self.primary_artists = primary_artists
self.feat_artists = feat_artists
self.album = album
self.song_object = self.add_to_db()
self.update_song()
self.add_relations()
def __init__(self, entry_dict):
self.entry_dict = entry_dict
self.headword = self.entry_dict['head']['headword']
self.slug = slugify(self.headword)
self.letter = self.get_letter()
self.xml_id = self.entry_dict['@eid']
self.forms = []
self.publish = False if self.entry_dict['@publish'] == 'no' else True
self.entry_object = self.add_to_db()
self.updated = self.check_if_updated()
self.extract_forms()
self.update_entry()
self.extract_lexemes()
self.sense_count = 0
self.example_count = 0
def song_release_date_tree(request, song_slug):
results = Song.objects.filter(slug=song_slug)
if results:
song = results[0]
network = dict()
cache = set()
for s in Song.objects.filter(release_date=song.release_date, examples__isnull=False).order_by('artist_name'):
if s != song and s.slug not in cache:
cache.add(s.slug)
artist_name = s.artist_name
if artist_name not in network:
network[artist_name] = [(s.title, s.slug)]
else:
network[artist_name].extend([(s.title, s.slug)])
if network:
data = {
'name': song.release_date_string,
'children': [
{
'name': reformat_name(s),
"link": "/artists/" + slugify(s),
'children': [
{
'name': t[0],
'link': "/songs/" + t[1]
} for t in network[s]]
} for s in network
]
}
return Response(data)
else:
return Response({})
else:
return Response({})
def add_origin(self, place_name):
place_slug = slugify(place_name)
place = Place.objects.filter(slug=place_slug).first()
if place:
print('Adding origin', place.name, 'to', self.name)
self.origin.add(place)
def __init__(self, synset_id):
self.synset_id = synset_id
self.slug = slugify(self.synset_id)
self.synset_object = self.add_to_db()
self.update_synset_object()
def create(cls, full_name):
slug = slugify(full_name)
name = extract_short_name(full_name)
place = cls(slug=slug, full_name=full_name, name=name)
return place
def add_aka(self, aka_name):
aka_slug = slugify(aka_name)
aka = Artist.objects.filter(slug=aka_slug).first()
if aka:
print(self.name, 'now also known as', aka.name)
self.also_known_as.add(aka)
def __init__(self, entry_object, label, frequency):
self.parent_entry = entry_object
self.label = label
self.frequency = frequency
self.slug = slugify(self.label)
def update_example(self):
self.example_object.json = self.example_dict
self.example_object.artist_slug = slugify(self.artist_name)
self.example_object.save()
def __init__(self, name, origin=None):
self.name = name
self.origin = origin
self.slug = slugify(self.name)
self.artist_object = self.add_to_db()
self.update_artist()
def __init__(self, name):
self.name = make_label_from_camel_case(name)
self.slug = slugify(self.name)
self.semantic_class_object = self.add_to_db()
self.update_semantic_class_object()
def __init__(self, name):
self.name = make_label_from_camel_case(name)
self.slug = slugify(self.name)
self.domain_object = self.add_to_db()
self.update_domain_object()
