moviewyrm/fedireads/connectors/abstract_connector.py

318 lines
9 KiB
Python
Raw Normal View History

2020-03-07 20:22:28 +00:00
''' functionality outline for a book data connector '''
from abc import ABC, abstractmethod
2020-03-30 00:40:51 +00:00
from dateutil import parser
import pytz
import requests
2020-03-07 20:22:28 +00:00
2020-05-10 19:56:59 +00:00
from django.db import transaction
from fedireads import models
2020-03-07 20:22:28 +00:00
class AbstractConnector(ABC):
''' generic book data connector '''
def __init__(self, identifier):
2020-03-07 20:22:28 +00:00
# load connector settings
info = models.Connector.objects.get(identifier=identifier)
2020-03-28 23:01:02 +00:00
self.connector = info
2020-03-07 20:22:28 +00:00
2020-05-09 00:41:23 +00:00
self.book_mappings = {}
2020-05-10 19:56:59 +00:00
self.key_mappings = {
'isbn_13': ('isbn_13', None),
'isbn_10': ('isbn_10', None),
'oclc_numbers': ('oclc_number', None),
'lccn': ('lccn', None),
}
2020-05-09 00:41:23 +00:00
2020-05-10 18:29:10 +00:00
fields = [
'base_url',
'books_url',
'covers_url',
'search_url',
'key_name',
'max_query_count',
'name',
'identifier',
'local'
]
for field in fields:
setattr(self, field, getattr(info, field))
def is_available(self):
''' check if you're allowed to use this connector '''
2020-05-04 00:53:14 +00:00
if self.max_query_count is not None:
if self.connector.query_count >= self.max_query_count:
return False
return True
2020-03-07 20:22:28 +00:00
2020-03-28 04:28:52 +00:00
2020-03-07 20:22:28 +00:00
def search(self, query):
''' free text search '''
resp = requests.get(
'%s%s' % (self.search_url, query),
headers={
'Accept': 'application/json; charset=utf-8',
},
)
if not resp.ok:
resp.raise_for_status()
data = resp.json()
results = []
for doc in self.parse_search_data(data)[:10]:
results.append(self.format_search_result(doc))
return results
2020-05-10 19:56:59 +00:00
def get_or_create_book(self, remote_id):
''' pull up a book record by whatever means possible '''
# try to load the book
book = models.Book.objects.select_subclasses().filter(
remote_id=remote_id
).first()
if book:
if isinstance(book, models.Work):
return book.default_edition
return book
# no book was found, so we start creating a new one
data = get_data(remote_id)
work = None
edition = None
if self.is_work_data(data):
work_data = data
# if we requested a work and there's already an edition, we're set
work = self.match_from_mappings(work_data)
if work and work.default_edition:
return work.default_edition
# no such luck, we need more information.
try:
edition_data = self.get_edition_from_work_data(work_data)
except KeyError:
# hack: re-use the work data as the edition data
# this is why remote ids aren't necessarily unique
edition_data = data
else:
edition_data = data
edition = self.match_from_mappings(edition_data)
# no need to figure out about the work if we already know about it
if edition and edition.parent_work:
return edition
# no such luck, we need more information.
try:
work_data = self.get_work_from_edition_date(edition_data)
except KeyError:
# remember this hack: re-use the work data as the edition data
work_data = data
# at this point, we need to figure out the work, edition, or both
# atomic so that we don't save a work with no edition for vice versa
with transaction.atomic():
if not work:
work_key = work_data.get('url')
work = self.create_book(work_key, work_data, models.Work)
if not edition:
ed_key = edition_data.get('url')
edition = self.create_book(ed_key, edition_data, models.Edition)
edition.default = True
edition.parent_work = work
edition.save()
# now's our change to fill in author gaps
if not edition.authors and work.authors:
edition.authors.set(work.authors.all())
edition.author_text = work.author_text
edition.save()
return edition
def create_book(self, remote_id, data, model):
''' create a work or edition from data '''
2020-05-10 19:56:59 +00:00
book = model.objects.create(
remote_id=remote_id,
title=data['title'],
connector=self.connector,
)
return self.update_book_from_data(book, data)
2020-05-10 19:56:59 +00:00
def update_book_from_data(self, book, data, update_cover=True):
''' for creating a new book or syncing with data '''
book = update_from_mappings(book, data, self.book_mappings)
2020-05-10 19:56:59 +00:00
for author in self.get_authors_from_data(data):
book.authors.add(author)
2020-05-10 19:56:59 +00:00
book.author_text = ', '.join(a.name for a in book.authors.all())
book.save()
if not update_cover:
return book
cover = self.get_cover_from_data(data)
if cover:
book.cover.save(*cover, save=True)
2020-05-09 00:41:23 +00:00
return book
2020-05-09 19:53:55 +00:00
def update_book(self, book, data=None):
''' load new data '''
if not book.sync and not book.sync_cover:
return
if not data:
key = getattr(book, self.key_name)
data = self.load_book_data(key)
if book.sync:
2020-05-10 19:56:59 +00:00
book = self.update_book_from_data(
book, data, update_cover=book.sync_cover)
else:
cover = self.get_cover_from_data(data)
if cover:
book.cover.save(*cover, save=True)
2020-05-09 19:53:55 +00:00
return book
2020-05-10 19:56:59 +00:00
def match_from_mappings(self, data):
''' try to find existing copies of this book using various keys '''
keys = [
('openlibrary_key', models.Book),
('librarything_key', models.Book),
('goodreads_key', models.Book),
('lccn', models.Work),
('isbn_10', models.Edition),
('isbn_13', models.Edition),
('oclc_number', models.Edition),
('asin', models.Edition),
]
noop = lambda x: x
for key, model in keys:
formatter = None
if key in self.key_mappings:
key, formatter = self.key_mappings[key]
if not formatter:
formatter = noop
value = data.get(key)
if not value:
continue
value = formatter(value)
match = model.objects.select_subclasses().filter(
**{key: value}).first()
if match:
return match
@abstractmethod
def is_work_data(self, data):
''' differentiate works and editions '''
@abstractmethod
def get_edition_from_work_data(self, data):
''' every work needs at least one edition '''
@abstractmethod
def get_work_from_edition_date(self, data):
''' every edition needs a work '''
2020-05-09 19:53:55 +00:00
@abstractmethod
def get_authors_from_data(self, data):
''' load author data '''
@abstractmethod
def get_cover_from_data(self, data):
''' load cover '''
@abstractmethod
def parse_search_data(self, data):
''' turn the result json from a search into a list '''
@abstractmethod
def format_search_result(self, search_result):
''' create a SearchResult obj from json '''
2020-03-07 20:22:28 +00:00
2020-04-02 05:11:31 +00:00
@abstractmethod
def expand_book_data(self, book):
''' get more info on a book '''
2020-03-28 19:55:53 +00:00
def update_from_mappings(obj, data, mappings):
''' assign data to model with mappings '''
noop = lambda x: x
2020-03-28 23:30:54 +00:00
mappings['authors'] = ('', noop)
mappings['parent_work'] = ('', noop)
2020-03-28 19:55:53 +00:00
for (key, value) in data.items():
formatter = None
if key in mappings:
key, formatter = mappings[key]
if not formatter:
formatter = noop
if key == 'id':
continue
2020-05-10 21:56:53 +00:00
try:
hasattr(obj, key)
except ValueError:
2020-03-28 19:55:53 +00:00
obj.__setattr__(key, formatter(value))
return obj
2020-03-30 00:40:51 +00:00
def get_date(date_string):
''' helper function to try to interpret dates '''
2020-05-09 19:33:02 +00:00
if not date_string:
return None
2020-05-10 21:53:45 +00:00
2020-03-30 00:40:51 +00:00
try:
return pytz.utc.localize(parser.parse(date_string))
2020-05-10 21:53:45 +00:00
except ValueError:
pass
try:
return parser.parse(date_string)
2020-03-30 00:40:51 +00:00
except ValueError:
return None
def get_data(url):
''' wrapper for request.get '''
resp = requests.get(
url,
headers={
2020-05-10 19:56:59 +00:00
'Accept': 'application/json; charset=utf-8',
},
)
if not resp.ok:
resp.raise_for_status()
2020-05-09 19:59:06 +00:00
data = resp.json()
return data
2020-05-10 18:29:10 +00:00
class SearchResult(object):
2020-03-07 20:22:28 +00:00
''' standardized search result object '''
def __init__(self, title, key, author, year):
2020-03-07 20:22:28 +00:00
self.title = title
self.key = key
self.author = author
self.year = year
def __repr__(self):
return "<SearchResult key={!r} title={!r} author={!r}>".format(
self.key, self.title, self.author)