philoch-bib-sdk 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

philoch_bib_sdk/converters/plaintext/journal/parser.py

@@ -0,0 +1,36 @@
+import traceback
+from aletk.ResultMonad import Ok, Err
+from aletk.utils import get_logger, remove_extra_whitespace
+from philoch_bib_sdk.logic.models import Journal, BibStringAttr, TBibString
+
+lgr = get_logger(__name__)
+
+
+def parse_journal(text: str, bibstring_type: TBibString) -> Ok[Journal | None] | Err:
+    """
+    Parse a journal string into a Journal object.
+    """
+    try:
+        if text == "":
+            lgr.debug("Empty journal string, returning None.")
+            return Ok(None)
+
+        # Normalize the text by removing extra whitespace
+        normalized_text = remove_extra_whitespace(text)
+
+        journal = Journal(
+            name=BibStringAttr(**{str(bibstring_type): normalized_text}),
+            issn_electronic="",
+            issn_print="",
+        )
+
+        return Ok(journal)
+
+    except Exception as e:
+        error_message = f"Error parsing journal string '{text}': {e}"
+        return Err(
+            message=error_message,
+            code=-1,
+            error_type=f"{e.__class__.__name__}",
+            error_trace=traceback.format_exc(),
+        )

philoch_bib_sdk/converters/plaintext/shared/renderable_formatter.py

@@ -0,0 +1,25 @@
+from philoch_bib_sdk.logic.models import BaseRenderable, BaseNamedRenderable, TBibString
+
+
+def format_renderable(
+    renderable: BaseRenderable | BaseNamedRenderable,
+    bibstring_type: TBibString,
+) -> str:
+    """
+    Format a base renderable object into a string representation.
+    """
+
+    match renderable:
+
+        case BaseRenderable(text, id):
+            if not text:
+                return ""
+            return f"{getattr(text, bibstring_type)}"
+
+        case BaseNamedRenderable(name, id):
+            if not name:
+                return ""
+            return f"{getattr(name, bibstring_type)}"
+
+        case _:
+            raise TypeError("Invalid type for renderable")

philoch_bib_sdk/logic/default_models.py

@@ -0,0 +1,120 @@
+from typing import Tuple, TypedDict, Unpack
+
+from philoch_bib_sdk.logic.models import (
+    Author,
+    BaseNamedRenderable,
+    BaseRenderable,
+    BibItem,
+    BibStringAttr,
+    Journal,
+)
+
+
+class BibStringArgs(TypedDict, total=False):
+    latex: str
+    unicode: str
+    simplified: str
+
+
+def default_bib_string(**kwargs: Unpack[BibStringArgs]) -> BibStringAttr:
+    """
+    Create a default BibString object, given a dictionary with any (or None) of its attributes. Defaults to empty strings if not provided.
+    """
+    return BibStringAttr(
+        latex=kwargs.get("latex", ""),
+        unicode=kwargs.get("unicode", ""),
+        simplified=kwargs.get("simplified", ""),
+    )
+
+
+############
+# Base Renderables
+############
+
+
+class BaseRenderableArgs(TypedDict, total=False):
+    text: BibStringArgs
+    id: int | None
+
+
+def default_base_renderable(**kwargs: Unpack[BaseRenderableArgs]) -> BaseRenderable:
+    """
+    Create a default BaseRenderable object, given a dictionary with any (or None) of its attributes. Defaults to empty strings if not provided.
+    """
+    return BaseRenderable(
+        text=default_bib_string(**kwargs.get("text", {})),
+        id=kwargs.get("id", None),
+    )
+
+
+class BaseNamedRenderableArgs(TypedDict, total=False):
+    name: BibStringArgs
+    id: int | None
+
+
+def default_base_named_renderable(**kwargs: Unpack[BaseNamedRenderableArgs]) -> BaseNamedRenderable:
+    """
+    Create a default BaseNamedRenderable object, given a dictionary with any (or None) of its attributes. Defaults to empty strings if not provided.
+    """
+    return BaseNamedRenderable(
+        name=default_bib_string(**kwargs.get("name", {})),
+        id=kwargs.get("id", None),
+    )
+
+
+############
+# Author
+############
+
+
+class AuthorArgs(TypedDict, total=False):
+    given_name: BibStringArgs
+    family_name: BibStringArgs
+    mononym: BibStringArgs
+    shorthand: BibStringArgs
+    famous_name: BibStringArgs
+    publications: Tuple[BibItem, ...]
+    id: int | None
+
+
+def default_author(**kwargs: Unpack[AuthorArgs]) -> Author:
+    """
+    Create a default Author object, given a dictionary with any (or None) of its attributes. Defaults to empty strings and an empty tuple for publications if not provided.
+    """
+
+    return Author(
+        given_name=default_bib_string(**kwargs.get("given_name", {})),
+        family_name=default_bib_string(**kwargs.get("family_name", {})),
+        mononym=default_bib_string(**kwargs.get("mononym", {})),
+        shorthand=default_bib_string(**kwargs.get("shorthand", {})),
+        famous_name=default_bib_string(**kwargs.get("famous_name", {})),
+        publications=kwargs.get("publications", ()),
+        id=kwargs.get("id", None),
+    )
+
+
+############
+# Journal
+############
+
+
+class JournalArgs(TypedDict, total=False):
+    name: BibStringArgs
+    issn_print: str
+    issn_electronic: str
+    id: int | None
+
+
+def default_journal(**kwargs: Unpack[JournalArgs]) -> Journal | None:
+    """
+    Create a default Journal object, given a dictionary with any (or None) of its attributes. Defaults to empty strings if not provided.
+    """
+    if kwargs == {}:
+        return None
+
+    return Journal(
+        name=default_bib_string(**kwargs.get("name", {})),
+        issn_print=kwargs.get("issn_print", ""),
+        issn_electronic=kwargs.get("issn_electronic", ""),
+        id=kwargs.get("id", None),
+    )

philoch_bib_sdk/logic/functions/comparator.py

@@ -0,0 +1,134 @@
+from aletk.utils import get_logger, fuzzy_match_score, remove_extra_whitespace
+
+from typing import TypedDict
+from philoch_bib_sdk.converters.plaintext.author.formatter import format_author
+from philoch_bib_sdk.logic.models import BibItem, BibItemDateAttr, TBibString
+
+
+logger = get_logger(__name__)
+
+
+class BibItemScore(TypedDict):
+    score: int
+    score_title: int
+    score_author: int
+    score_year: int
+
+
+class ScoredBibItems(TypedDict):
+    reference: BibItem
+    subject: BibItem
+    score: BibItemScore
+
+
+UNDESIRED_TITLE_KEYWORDS = ["errata", "review"]
+
+
+def _score_title(title_1: str, title_2: str) -> int:
+
+    norm_title_1 = remove_extra_whitespace(title_1).lower()
+    norm_title_2 = remove_extra_whitespace(title_2).lower()
+
+    if not norm_title_1 or not norm_title_2:
+        raise ValueError("Titles cannot be empty for comparison")
+
+    title_score = fuzzy_match_score(
+        norm_title_1,
+        norm_title_2,
+    )
+
+    # Might catch cases in which one doesn't include the subtitle
+    one_included_in_the_other = (norm_title_1 in norm_title_2) or (norm_title_2 in norm_title_1)
+
+    undesired_kws_in_title_1 = {kw for kw in UNDESIRED_TITLE_KEYWORDS if kw in norm_title_1}
+
+    undesired_kws_in_title_2 = {kw for kw in UNDESIRED_TITLE_KEYWORDS if kw in norm_title_2}
+
+    # disjunction
+    undesired_kws = undesired_kws_in_title_1.symmetric_difference(undesired_kws_in_title_2)
+
+    undesired_kws_mismatch = True if len(undesired_kws) > 0 else False
+
+    if ((title_score > 85) or one_included_in_the_other) and not undesired_kws_mismatch:
+        title_score += 100
+
+    for _ in undesired_kws:
+        title_score -= 50
+
+    return title_score
+
+
+def _score_author(author_1_full_name: str, author_2_full_name: str) -> int:
+    stripped_author_1 = remove_extra_whitespace(author_1_full_name)
+    stripped_author_2 = remove_extra_whitespace(author_2_full_name)
+
+    if not stripped_author_1 or not stripped_author_2:
+        raise ValueError("Authors cannot be empty for comparison")
+
+    author_score = fuzzy_match_score(
+        stripped_author_1,
+        stripped_author_2,
+    )
+
+    if author_score > 85:
+        author_score += 100
+
+    return author_score
+
+
+def _score_year(year_1: int, year_2: int, range_offset: int = 1) -> int:
+
+    if not year_1 or not year_2:
+        raise ValueError("Years cannot be empty for comparison")
+
+    if not any(isinstance(year, int) for year in (year_1, year_2)):
+        if year_1 == year_2:
+            return 100
+        else:
+            return 0
+
+    range = [year_1 - range_offset, year_1, year_1 + range_offset]
+
+    if year_2 in range:
+        return 100
+    else:
+        return 0
+
+
+def compare_bibitems(reference: BibItem, subject: BibItem, bibstring_type: TBibString) -> ScoredBibItems:
+    """
+    Calculate the score of two BibItems based on their title, author, and year.
+    The scoring is done using fuzzy matching for title and author, and exact matching for year.
+    The final score is a combination of the individual scores.
+    """
+
+    logger.debug(f"Scoring bibitems: {reference}, {subject}")
+
+    title_1 = getattr(reference.title, bibstring_type)
+    title_2 = getattr(subject.title, bibstring_type)
+    title_score = _score_title(title_1, title_2)
+
+    author_1_full_name = format_author(reference.author, bibstring_type)
+    author_2_full_name = format_author(subject.author, bibstring_type)
+
+    author_score = _score_author(author_1_full_name, author_2_full_name)
+
+    if isinstance(reference.date, BibItemDateAttr) and isinstance(subject.date, BibItemDateAttr):
+        year_1 = reference.date.year
+        year_2 = subject.date.year
+        year_score = _score_year(year_1, year_2)
+    else:
+        year_score = 0
+
+    total_score = title_score + author_score + year_score
+
+    return {
+        "reference": reference,
+        "subject": subject,
+        "score": {
+            "score": total_score,
+            "score_title": title_score,
+            "score_author": author_score,
+            "score_year": year_score,
+        },
+    }

philoch_bib_sdk/logic/literals.py

@@ -1,7 +1,6 @@
 from typing import Literal
 
 type TBibTeXEntryType = Literal[
-    "",
     "article",
     "book",
     "incollection",
@@ -12,15 +11,20 @@ type TBibTeXEntryType = Literal[
     "proceedings",
     "techreport",
     "unpublished",
+    "UNKNOWN",
 ]
 
-type TPubState = Literal[
+type TBasicPubState = Literal[
     "",
     "unpub",
+    "forthcoming",
+]
+
+type TPubState = Literal[
+    TBasicPubState,
     "inwork",
     "submitted",
     "published",
-    "forthcoming",
 ]
 
 type TLanguageID = Literal[