def test_from_to_dict(self):
file, created = File.objects.get_or_create(
file=SimpleUploadedFile("test.txt", b"Lorem ipsum dolorem"))
self.assertTrue(created)
self.assertIsNotNone(file.id)
self.assertEquals(
{"path": os.path.join(settings.MEDIA_ROOT, "files/test.txt")},
file.to_dict(),
)
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))
self.assertEquals(f"files/{os.path.basename(f.name)}",
file.file.name)
self.assertEquals(
{
"path":
os.path.join(settings.MEDIA_ROOT, "files",
os.path.basename(f.name))
},
file.to_dict(),
)
self.assertEquals((file, False), File.from_dict(file.to_dict()))
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 edit(self: T, field: str, value: str, *args, **kwargs):
"""Change field by given value."""
assert field in [
"alternate_title",
"alternate-title",
"binding",
"cover",
"isbn",
"person",
"publishing_date",
"publishing-date",
"publisher",
"language",
"link",
"file",
]
if field == "alternate_title" or field == "alternate-title":
self.alternate_title = value
elif field == "binding":
self.binding = Binding.get_or_create(value)
elif field == "cover":
self.cover_image.save(os.path.basename(str(value)),
DJFile(open(str(value), "rb")))
elif field == "isbn":
self.isbn = value
elif field == "person":
person = Person.get_or_create(value)
if self.persons.filter(pk=person.pk).exists():
self.persons.remove(person)
else:
self.persons.add(person)
elif field == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "publisher":
self.publisher = Publisher.get_or_create(value)
elif field == "language":
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
elif field == "link":
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
elif field == "file":
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
def from_dict(cls: Type[T], data: Dict, magazine: Magazine) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d"
).date()
issue, created = cls.objects.get_or_create(
issue=data["issue"], magazine=magazine, defaults=defaults
)
if "cover_image" in data and data["cover_image"]:
issue.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"]:
if type(i) == dict:
issue.languages.add(Language.from_dict(i)[0])
else:
issue.languages.add(Language.get_or_create(i))
if "links" in data and data["links"]:
for i in data["links"]:
issue.links.add(Link.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, issue)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, issue)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, issue)
issue.save()
return issue, created
def edit(self: T, field: str, value: Union[str, datetime.date], *args,
**kwargs):
"""Change field by given value."""
fields = [
"title",
"author",
"publishing_date",
"publishing-date",
"journal",
"volume",
"language",
"file",
"link",
"bibtex",
]
assert field in fields
if field == "title":
self.title = value
elif field == "author" and isinstance(value, str):
author = Person.get_or_create(value)
if self.authors.filter(pk=author.pk).exists():
self.authors.remove(author)
else:
self.authors.add(author)
elif field == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "journal" and isinstance(value, str):
self.journal = Journal.get_or_create(value)
elif field == "volume":
self.volume = value
elif field == "bibtex":
self.bibtex = value
elif field == "language" and isinstance(value, str):
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
elif field == "link" and isinstance(value, str):
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
elif field == "file":
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
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 edit(self: T, field: str, value: Union[str, datetime.date], *args, **kwargs):
"""Change field by given value."""
fields = [
"issue",
"publishing_date",
"publishing-date",
"cover",
"language",
"file",
"link",
]
assert field in fields
if field == "issue":
self.issue = value
elif field == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "cover":
self.cover_image.save(
os.path.basename(str(value)), DJFile(open(str(value), "rb"))
)
elif field == "language" and isinstance(value, str):
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
elif field == "link" and isinstance(value, str):
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
elif field == "file" and isinstance(value, str):
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
def from_bibtex(cls: Type[T],
bibtex: str,
files: List[str] = [],
bibfile: Optional[str] = None) -> List[Tuple[T, bool]]:
"""Create from bibtext."""
bib_database = BibTexParser(common_strings=True,
homogenize_fields=True).parse(bibtex)
if len(files) < len(bib_database.entries):
for i in range(len(files), len(bib_database.entries)):
files.append("")
papers = []
for entry, file in zip(bib_database.entries, files):
title = entry["title"].strip() if "title" in entry else ""
authors = []
entry["author"] = re.sub(r"\s*\n\s*",
" ",
entry["author"],
flags=re.S)
for author in re.compile(r"\s+and\s+").split(entry["author"]):
if "," in author:
s = author.split(",")
authors.append({"name": f"{s[1].strip()} {s[0].strip()}"})
else:
authors.append({"name": author.strip()})
journal = {
"name": entry["journal"].strip()
} if "journal" in entry else None
volume = entry["volume"].strip() if "volume" in entry else None
if "number" in entry:
volume = f"{volume}.{entry['number']}"
if "eprint" in entry and not volume:
volume = entry["eprint"].strip()
publisher = ({
"name": entry["publisher"].strip()
} if "publisher" in entry else None)
year = int(entry["year"].strip()) if "year" in entry else None
month = entry["month"].strip() if "month" in entry else None
day = entry["day"].strip() if "day" in entry else None
if year and month and day:
date = datetime.datetime.strptime(f"{day} {month} {year}",
"%d %B %Y")
elif year and month:
try:
date = datetime.datetime.strptime(f"{month} {year}",
"%B %Y")
except ValueError:
date = datetime.datetime.strptime(f"{month} {year}",
"%b %Y")
elif year:
date = datetime.datetime(year, 1, 1)
pub_date = None
if "timestamp" in entry:
pub_date = (datetime.datetime.strptime(
entry["timestamp"].strip(),
"%a, %d %b %Y %H:%M:%S %z").date().strftime("%Y-%m-%d"))
elif date:
pub_date = date.date().strftime("%Y-%m-%d")
if "link" in entry:
url: Optional[Dict] = {"url": entry["link"].strip()}
elif "url" in entry:
url = {"url": entry["url"].strip()}
else:
url = None
papers.append(
cls.from_dict({
"title": title,
"authors": authors,
"journal": journal,
"volume": volume,
"publisher": publisher,
"publishing_date": pub_date,
"links": [url],
"bibtex": bibtex,
}))
if file:
papers[-1][0].files.add(File.from_dict({"path": file})[0])
papers[-1][0].save()
if bibfile:
papers[-1][0].files.add(File.from_dict({"path": bibfile})[0])
papers[-1][0].save()
return papers
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(),
)
