def _create_room(self, room, cinema):
turtle_room = to_turtle_fmt(room)
turtle_cinema = to_turtle_fmt(cinema)
encoded_room_name = f"room_{turtle_room}_{turtle_cinema}"
self.g.add((self.baseURI[encoded_room_name], RDF.type,
self.baseURI.cinema_room))
self.g.add((self.baseURI[encoded_room_name], self.baseURI.cinema,
self._create_cinema(cinema)))
self.g.add((self.baseURI[encoded_room_name], self.dbpedia.Name,
Literal(room)))
return self.baseURI[encoded_room_name]
def _create_cinema(self, cinema):
encoded_cinema_name = to_turtle_fmt(cinema)
self.g.add(
(self.baseURI[encoded_cinema_name], RDF.type, self.dbpedia.Cinema))
self.g.add((self.baseURI[encoded_cinema_name], self.dbpedia.Name,
Literal(cinema)))
return self.baseURI[encoded_cinema_name]
def add_origins(self, movie_title, movie):
for origin in movie.origins:
encoded_origin = to_turtle_fmt(origin)
origin_uri = self.baseURI[encoded_origin]
self.g.add((origin_uri, RDF.type, self.dbpedia.Country))
self.g.add((origin_uri, self.dbpedia.Name, Literal(origin)))
self.g.add((movie_title, self.dbpedia.origin, origin_uri))
def add_genres(self, movie_title, movie):
for genre in movie.genres:
encoded_genre = to_turtle_fmt(genre)
self.g.add((self.baseURI[encoded_genre], RDF.type,
self.dbpedia.MovieGenre))
self.g.add((self.baseURI[encoded_genre], self.dbpedia.Name,
Literal(genre)))
self.g.add(
(movie_title, self.dbpedia.genre, self.baseURI[encoded_genre]))
def add_characters(self, movie_title, movie):
for character in movie.characters:
# Beware of character reptition across movies. This could be a
# problem, but fixing it sacrifices legibility. Hi future me!
encoded_character_name = to_turtle_fmt(character)
self.g.add((self.baseURI[encoded_character_name], RDF.type,
self.dbpedia.FictionalCharacter))
self.g.add(
(self.baseURI[encoded_character_name], self.dbpedia.Name,
Literal(character)))
self.g.add((movie_title, self.baseURI.hasCharacter,
self.baseURI[encoded_character_name]))
def _create_person(self, person, person_type):
encoded_person_name = to_turtle_fmt(person.name)
person_URI = self.baseURI[encoded_person_name]
self.g.add((person_URI, RDF.type, person_type))
self.g.add((person_URI, self.dbpedia.Name, Literal(person.name)))
if person.url:
self.g.add(
(person_URI, self.baseURI.url, self.url_literal(person.url)))
if person.image:
image_uri = self._create_image(person.name, image_url=person.image)
self.g.add((person_URI, self.dbpedia.thumbnail, image_uri))
return person_URI
def add_aggregated_ratings(self, movie_title, movie):
for index, rating in enumerate(movie.aggregated_ratings, 1):
rating_uri = self._create_rating(to_turtle_fmt(movie.name), rating,
index)
self.g.add((rating_uri, self.schema.ratingCount,
Literal(rating.rating_count, datatype=XSD.integer)))
if review_count := rating.review_count:
self.g.add((rating_uri, self.schema.reviewCount,
Literal(review_count, datatype=XSD.integer)))
self.g.add((rating_uri, self.dcterms.source,
self.url_literal(rating.source)))
self.g.add((movie_title, self.schema.aggregateRating, rating_uri))
def _create_language(self, movie_uri, lang):
encoded_lang = to_turtle_fmt(lang)
# I'm sorry it's the only one it doesn't detect
if encoded_lang == "Castellano":
lang_code = "es"
else:
lang_code = langcodes.find(lang).language
language_uri = self.baseURI[encoded_lang]
self.g.add((language_uri, RDF.type, self.dbpedia.Language))
self.g.add(
(language_uri, self.dbpedia.languageCode, Literal(lang_code)))
return language_uri
def _create_company(self, company, movie, i=1):
if company.name:
encoded_company_name = to_turtle_fmt(company.name)
else:
encoded_company_name = f"{to_turtle_fmt(movie.name)}_company_{i}"
self.g.add((self.baseURI[encoded_company_name], RDF.type,
self.dbpedia.Company))
if company.name:
self.g.add((self.baseURI[encoded_company_name], self.dbpedia.Name,
Literal(company.name)))
if company.url:
self.g.add((self.baseURI[encoded_company_name], self.baseURI.url,
self.url_literal(company.url)))
return self.baseURI[encoded_company_name]
def build_movie(self, movie_obj):
movie_title = self.baseURI[to_turtle_fmt(movie_obj.name)]
self.g.add((movie_title, RDF.type, self.dbpedia.Film))
self.g.add((movie_title, self.dbpedia.title, Literal(movie_obj.name)))
self.add_synopsis(movie_title, movie_obj)
self.add_content_rating(movie_title, movie_obj)
self.add_source_urls(movie_title, movie_obj)
self.add_production_company(movie_title, movie_obj)
self.add_aggregated_ratings(movie_title, movie_obj)
self.add_reviews(movie_title, movie_obj)
self.add_images(movie_title, movie_obj)
self.add_actors(movie_title, movie_obj)
self.add_characters(movie_title, movie_obj)
self.add_directors(movie_title, movie_obj)
self.add_authors(movie_title, movie_obj)
self.add_genres(movie_title, movie_obj)
self.add_keywords(movie_title, movie_obj)
self.add_duration(movie_title, movie_obj)
self.add_video(movie_title, movie_obj)
self.add_origins(movie_title, movie_obj)
self.add_released_date(movie_title, movie_obj)
self.add_shows(movie_title, movie_obj)
self.add_languages(movie_title, movie_obj)