def test_delete(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
deleted = person.delete()
self.assertIsNone(person.id)
self.assertEquals((1, {"persons.Person": 1}), deleted)
person, created = Person.from_dict({
"name":
"Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
})
self.assertTrue(created)
self.assertIsNotNone(person.id)
deleted = person.delete()
self.assertIsNone(person.id)
self.assertEquals(
(3, {
"persons.Person": 1,
"persons.Person_links": 1,
"links.Link": 1
}),
deleted,
)
def test_search(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person, created = Person.from_dict({"name": "Maria Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person, created = Person.from_dict({"name": "Maria Vogel"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(3, Person.objects.all().count())
self.assertEquals(2, Person.search("Maria").count())
self.assertEquals(2, Person.search("müller").count())
def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "series" in data and data["series"]:
defaults["series"] = Series.from_dict(data["series"])[0]
if "volume" in data and data["volume"]:
defaults["volume"] = data["volume"]
book, created = Book.objects.get_or_create(title=data["title"],
defaults=defaults)
if "authors" in data and data["authors"]:
for i in data["authors"]:
book.authors.add(Person.from_dict(i)[0])
if "genres" in data and data["genres"]:
for i in data["genres"]:
book.genres.add(Genre.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
book.links.add(Link.from_dict(i)[0])
return book, created
def test_from_to_dict(self):
link, created = Link.objects.get_or_create(
link="https://hans-mueller.de")
self.assertTrue(created)
self.assertIsNotNone(link.id)
person, created = Person.objects.get_or_create(name="Hans Müller")
person.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(
{
"name": "Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
},
person.to_dict(),
)
self.assertEquals(
(person, False),
Person.from_dict({
"name": "Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
}),
)
self.assertEquals((person, False),
Person.from_dict({"name": "Hans Müller"}))
person, created = Person.objects.get_or_create(name="Jane Bond")
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals({
"name": "Jane Bond",
"links": None
}, person.to_dict())
self.assertEquals((person, False),
Person.from_dict({
"name": "Jane Bond",
"links": None
}))
self.assertEquals((person, False),
Person.from_dict({"name": "Jane Bond"}))
def from_dict(cls: Type[T], data: Dict, book: Book) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "alternate_title" in data and data["alternate_title"]:
defaults["alternate_title"] = data["alternate_title"]
if "isbn" in data and data["isbn"]:
defaults["isbn"] = data["isbn"]
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d").date()
if "publisher" in data and data["publisher"]:
defaults["publisher"] = Publisher.from_dict(data["publisher"])[0]
if "binding" in data and data["binding"]:
defaults["binding"] = Binding.from_dict(data["binding"])[0]
if "bibtex" in data and data["bibtex"]:
defaults["bibtex"] = data["bibtex"]
edition, created = cls.objects.get_or_create(
book=book,
alternate_title=data["alternate_title"]
if "alternate_title" in data else None,
isbn=data["isbn"] if "isbn" in data else None,
publishing_date=data["publishing_date"]
if "publishing_date" in data else None,
defaults=defaults,
)
if "cover_image" in data and data["cover_image"]:
edition.cover_image.save(
os.path.basename(data["cover_image"]),
DJFile(open(data["cover_image"], "rb")),
)
if "languages" in data and data["languages"]:
for i in data["languages"]:
edition.languages.add(Language.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
edition.links.add(Link.from_dict(i)[0])
if "persons" in data and data["persons"]:
for i in data["persons"]:
edition.persons.add(Person.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, edition)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, edition)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, edition)
edition.save()
return edition, created
def test_print(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
with StringIO() as cout:
person.print(cout)
self.assertEquals(
"Field Value "
+
" \n=================================="
+
"==================================================================\n"
+
"Id 1 "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Name Hans Müller "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Links "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Books "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Editions "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Papers "
+
" \n__________________________________"
+
"__________________________________________________________________\n",
cout.getvalue(),
)
def test_get(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person2 = Person.get("Hans Müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
person2 = Person.get("müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
person2 = Person.get(str(person.id))
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
def test_get_or_create(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create("Hans Müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create(str(person.id))
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create("Franz Müller")
self.assertIsNotNone(person2)
self.assertNotEquals(person, person2)
self.assertEquals(2, Person.objects.count())
def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "journal" in data and data["journal"]:
defaults["journal"] = Journal.from_dict(data["journal"])[0]
if "volume" in data and data["volume"]:
defaults["volume"] = data["volume"]
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d").date()
if "bibtex" in data and data["bibtex"]:
defaults["bibtex"] = data["bibtex"]
paper, created = Paper.objects.get_or_create(title=data["title"],
defaults=defaults)
if "authors" in data and data["authors"]:
for i in data["authors"]:
paper.authors.add(Person.from_dict(i)[0])
if "languages" in data and data["languages"]:
for i in data["languages"]:
paper.languages.add(Language.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
paper.links.add(Link.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, paper)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, paper)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, paper)
paper.save()
return paper, created
def test_from_to_dict(self):
book, created = Book.objects.get_or_create(title="Cool")
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(
{
"title": "Cool",
"authors": None,
"series": None,
"volume": 0,
"genres": None,
"links": None,
},
book.to_dict(),
)
self.assertEquals((book, False), Book.from_dict(book.to_dict()))
self.assertEquals((book, False), Book.from_dict({"title": "Cool"}))
author, created = Person.from_dict({"name": "Max Mustermann"})
self.assertTrue(created)
self.assertIsNotNone(author.id)
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
genre, created = Genre.from_dict({"name": "Fiction"})
self.assertTrue(created)
self.assertIsNotNone(genre.id)
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
book, created = Book.objects.get_or_create(title="Example",
series=series,
volume=1)
book.authors.add(author)
book.genres.add(genre)
book.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(
{
"title": "Example",
"authors": [{
"name": "Max Mustermann",
"links": None
}],
"series": {
"name": "Secret Files",
"links": None
},
"volume": 1,
"genres": [{
"name": "Fiction"
}],
"links": [{
"url": "https://example.com"
}],
},
book.to_dict(),
)
self.assertEquals((book, False), Book.from_dict(book.to_dict()))
def test_edit(self):
series, created = Series.from_dict({"name": "Test Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
person, created = Person.from_dict({"name": "John Do"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
book, created = Book.from_dict({
"title": "Test2 Book",
"authors": [person.to_dict()],
"series": series.to_dict(),
"volume": 1.0,
"genres": [{
"name": "Romance"
}],
})
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(series, book.series)
self.assertEquals(person, book.authors.first())
book.edit("title", "IEEE Test Book")
self.assertEquals("IEEE Test Book", book.title)
book.edit("author", "Jane Do")
self.assertEquals(2, book.authors.count())
self.assertEquals("Jane Do", str(book.authors.all()[0]))
self.assertEquals("John Do", str(book.authors.all()[1]))
book.edit("author", str(person.id))
self.assertEquals(1, book.authors.count())
self.assertEquals("Jane Do", str(book.authors.all()[0]))
series, created = Series.from_dict({"name": "Space Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
book.edit("series", str(series.id))
self.assertEquals(series, book.series)
book.edit("volume", 0.75)
self.assertEquals(0.75, book.volume)
series, created = Series.from_dict({"name": "Deep Space Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
book.edit("series", "Deep Space")
self.assertEquals(series, book.series)
book.edit("genre", "SciFi")
self.assertEquals(2, book.genres.count())
self.assertEquals("Romance", book.genres.first().name)
self.assertEquals("SciFi", book.genres.last().name)
book.edit("genre", "1")
self.assertEquals(1, book.genres.count())
self.assertEquals("SciFi", book.genres.first().name)
book.edit("link", "https://deep.space")
self.assertEquals(1, book.links.count())
self.assertEquals("https://deep.space", book.links.first().link)
book.edit("link", "https://janedo.com/test2book")
self.assertEquals(2, book.links.count())
self.assertEquals("https://janedo.com/test2book",
book.links.last().link)
book.edit("link", "https://deep.space")
self.assertEquals(1, book.links.count())
self.assertEquals("https://janedo.com/test2book",
book.links.first().link)
def test_from_to_dict(self):
author1, created = Person.from_dict({"name": "John Doe"})
self.assertTrue(created)
self.assertIsNotNone(author1.id)
author2, created = Person.from_dict({"name": "Jane Doe"})
self.assertTrue(created)
self.assertIsNotNone(author2.id)
journal, created = Journal.from_dict({"name": "Science Journal"})
self.assertTrue(created)
self.assertIsNotNone(journal.id)
paper, created = Paper.objects.get_or_create(
title="Random new stuff", journal=journal, volume="1/2021"
)
paper.authors.add(author1)
paper.authors.add(author2)
self.assertTrue(created)
self.assertIsNotNone(paper.id)
self.assertEquals(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "1/2021",
"publishing_date": None,
"languages": None,
"files": None,
"bibtex": None,
"links": None,
"acquisitions": None,
"reads": None,
},
paper.to_dict(),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "1/2021",
"publishing_date": None,
"languages": None,
"files": None,
"bibtex": None,
"links": None,
"acquisitions": None,
"reads": None,
}
),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe"},
{"name": "John Doe"},
],
"journal": {"name": "Science Journal"},
"volume": "1/2021",
}
),
)
language, created = Language.from_dict({"name": "Englisch"})
self.assertTrue(created)
self.assertIsNotNone(language.id)
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
paper, created = Paper.objects.get_or_create(
title="Random Science stuff",
publishing_date=datetime.strptime("2021-01-01", "%Y-%m-%d").date(),
journal=journal,
volume="2/2021",
)
paper.authors.add(author1)
paper.authors.add(author2)
paper.languages.add(language)
paper.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(paper.id)
acquisition, created = Acquisition.from_dict(
{"date": "2021-01-02", "price": 10}, paper
)
self.assertTrue(created)
self.assertIsNotNone(acquisition.id)
read, created = Read.from_dict(
{"started": "2021-01-02", "finished": "2021-01-03"}, paper
)
self.assertTrue(created)
self.assertIsNotNone(read.id)
self.assertEquals(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"files": None,
"bibtex": None,
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
},
paper.to_dict(),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"files": None,
"bibtex": None,
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
}
),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe"},
{"name": "John Doe"},
],
"journal": {"name": "Science Journal"},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
}
),
)
with NamedTemporaryFile() as f:
f.write(b"Lorem ipsum dolorem")
file, created = File.from_dict({"path": f.name})
self.assertTrue(created)
self.assertIsNotNone(file.id)
self.assertEquals(
os.path.basename(f.name), os.path.basename(file.file.name)
)
paper, created = Paper.objects.get_or_create(
title="Boring Science stuff",
publishing_date=datetime.strptime("2021-02-01", "%Y-%m-%d").date(),
journal=journal,
volume="2/2021",
)
paper.authors.add(author1)
paper.authors.add(author2)
paper.languages.add(language)
paper.links.add(link)
paper.files.add(file)
paper.save()
self.assertTrue(created)
self.assertIsNotNone(paper.id)
self.assertEquals(
{
"title": "Boring Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-02-01",
"languages": [{"name": "Englisch"}],
"bibtex": None,
"links": [{"url": "https://example.com"}],
"files": [
{
"path": os.path.join(
settings.MEDIA_ROOT,
"papers",
str(paper.pk),
os.path.basename(f.name),
)
}
],
"acquisitions": None,
"reads": None,
},
paper.to_dict(),
)
def _person(args: Namespace, file: TextIO = sys.stdout):
person: Optional[Person] = None
if args.subparser == "add":
person, created = Person.from_dict(
{
"name": args.name,
"links": [Link.get_or_create(link).to_dict() for link in args.link],
}
)
if created:
stdout.write(
_('Successfully added person "%(name)s" with id "%(pk)d".')
% {"name": person.name, "pk": person.pk},
"=",
file=file,
)
person.print(file)
else:
stdout.write(
_('The person "%(name)s" already exists with id "%(pk)d", aborting...')
% {"name": person.name, "pk": person.pk},
"",
file=file,
)
elif args.subparser == "delete":
person = Person.get(args.person)
if person:
person.delete()
stdout.write(
_('Successfully deleted person with id "%(name)s".')
% {"name": person.name},
"",
file=file,
)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "edit":
person = Person.get(args.person)
if person:
person.edit(args.field, args.value)
stdout.write(
_('Successfully edited person "%(name)s" with id "%(pk)d".')
% {"name": person.name, "pk": person.pk},
"",
file=file,
)
person.print(file)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "info":
person = Person.get(args.person)
if person:
person.print(file)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "list":
if args.search:
persons = Person.search(args.search)
else:
persons = Person.objects.all()
stdout.write(
[
_("Id"),
_("Name"),
_("Number of books"),
_("Number of editions"),
_("Number of papers"),
],
"=",
[0.05, 0.4, 0.6, 0.8],
file=file,
)
for i, has_next in lookahead(persons):
stdout.write(
[i.id, i.name, i.books.count(), i.editions.count(), i.papers.count()],
"_" if has_next else "=",
[0.05, 0.4, 0.6, 0.8],
file=file,
)
