pub-analyzer 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pub_analyzer/internal/templates/author/works.typ

@@ -1,46 +1,133 @@
 // Works
 = Works.
 
-#linebreak()
+#let works_metrics_card(title: "Title", graph, body) = {
+  grid(
+    rows: (18pt, 175pt, 60pt),
+    columns: 100%,
+
+    [
+      #block(width: 100%, height: 100%)[
+        #align(center + horizon)[#text(style: "italic")[#title]]
+      ]
+    ],
+    [
+      #block(width: 100%, height: 100%)[
+        #align(center + horizon)[#graph]
+      ]
+    ],
+    [
+      #block(width: 100%, height: 100%, inset: (x: 5pt, y: 10pt))[#body]
+    ],
+  )
+}
 
 #grid(
   columns: (1fr, 1fr, 1fr),
-  column-gutter: 30pt,
+  column-gutter: 15pt,
   [
-    #align(center)[_Citation metrics_]
-    #parbreak()
-    - *Count:* {{ report.citation_resume.type_a_count + report.citation_resume.type_b_count }}
-    - *Type A:* {{ report.citation_resume.type_a_count }}
-    - *Type B:* {{ report.citation_resume.type_b_count }}
+    #let graph = {
+      canvas(length: 35%, {
+        chart.piechart(
+          (
+            {{ report.citation_summary.type_a_count }}, // Type A
+            {{ report.citation_summary.type_b_count }}  // Type B
+          ),
+          radius: 1,
+          slice-style: (BLUE, GREEN),
+          outer-label: (content: "%", radius: 115%),
+        )
+      })
+    }
+
+    #works_metrics_card(title: "Citation metrics", graph)[
+      #grid(
+        rows: auto, row-gutter: 10pt,
+        columns: (1fr, 1fr),
+
+        grid.cell(colspan: 2)[
+          *Count:* {{ report.citation_summary.type_a_count + report.citation_summary.type_b_count }}
+        ],
+        [#box(height: 7pt, width: 7pt, fill: BLUE) *Type A:* {{ report.citation_summary.type_a_count }}],
+        [#box(height: 7pt, width: 7pt, fill: GREEN) *Type B:* {{ report.citation_summary.type_b_count }}],
+      )
+    ]
   ],
   [
-    #align(center)[_Work Type_]
-    #parbreak()
-    {% for work_type in report.works_type_resume %}
-    - *{{ work_type.type_name }}:* {{ work_type.count }}
-    {% endfor %}
+    #let graph = {
+      canvas(length: 35%, {
+        chart.columnchart(
+          size: (2.45, 2.0),
+          y-grid: false,
+          bar-style: palette.new(
+            base: (stroke: none, fill: none),
+            colors: colors
+          ),
+          (
+            {% for work_type in report.works_type_summary[:4] %}
+            ("{{ work_type.type_name[:2]|capitalize }}", {{ work_type.count }}),
+            {% endfor %}
+          )
+        )
+      })
+    }
+    #works_metrics_card(title: "Work Type", graph)[
+      #grid(
+        rows: auto, row-gutter: 10pt,
+        columns: (1fr, 1fr),
+        column-gutter: 5pt,
+
+        grid.cell(colspan: 2)[
+          *Count:* {{ report.open_access_summary.model_dump().items()|sum(attribute="1") }}
+        ],
+
+        {% for work_type in report.works_type_summary[:4] %}
+        [
+          #box(height: 7pt, width: 7pt, fill: colors.at({{ loop.index0 }})) *{{ work_type.type_name|capitalize }}:* {{ work_type.count }}
+        ],
+        {% endfor %}
+      )
+    ]
   ],
   [
-    #align(center)[_Open Access_]
-    #parbreak()
-    #grid(
-      columns: (1fr, 1fr),
-      column-gutter: 15pt,
-      [
-        - *gold:* {{report.open_access_resume.gold}}
-        - *green:* {{report.open_access_resume.green}}
-        - *hybrid:* {{report.open_access_resume.hybrid}}
-      ],
-      [
-        - *bronze:* {{report.open_access_resume.bronze}}
-        - *closed:* {{report.open_access_resume.closed}}
-      ],
-    )
+    #let graph = {
+      canvas(length: 35%, {
+        chart.piechart(
+          (
+            {{report.open_access_summary.gold}},   // Gold
+            {{report.open_access_summary.green}},  // Green
+            {{report.open_access_summary.hybrid}}, // Hybrid
+            {{report.open_access_summary.bronze}}, // Bronze
+            {{report.open_access_summary.closed}}, // Closed
+          ),
+          radius: 1,
+          inner-radius: .4,
+          slice-style: (YELLOW, GREEN, RED, BLUE, GRAY),
+          outer-label: (content: "%", radius: 115%),
+        )
+      })
+    }
+    #works_metrics_card(title: "Open Access", graph)[
+      #grid(
+        rows: auto, row-gutter: 10pt,
+        columns: (1fr, 1fr, 1fr),
+        column-gutter: 5pt,
+
+        grid.cell(colspan: 3)[
+          *Count:* {{ report.open_access_summary.model_dump().items()|sum(attribute="1") }}
+        ],
+
+        [#box(height: 7pt, width: 7pt, fill: YELLOW) *Gold:* {{report.open_access_summary.gold}}],
+        [#box(height: 7pt, width: 7pt, fill: GREEN) *Green:* {{report.open_access_summary.green}}],
+        [#box(height: 7pt, width: 7pt, fill: BLUE) *Bronze:* {{report.open_access_summary.bronze}}],
+
+        [#box(height: 7pt, width: 7pt, fill: GRAY) *Closed:* {{report.open_access_summary.closed}}],
+        [#box(height: 7pt, width: 7pt, fill: RED) *Hybrid:* {{report.open_access_summary.hybrid}}],
+      )
+    ]
   ],
 )
 
-#linebreak()
-
 #align(center, text(11pt)[Works from {{ report.works[0].work.publication_year }} to {{ report.works[-1].work.publication_year }}])
 #table(
   columns: (auto, 3fr, auto, auto, auto, auto, auto, auto, auto),
@@ -56,9 +143,9 @@
   [{{ work.work.type }}],
   [{% if work.work.ids.doi %}#underline([#link("{{ work.work.ids.doi }}")[DOI]]){% else %}-{% endif %}],
   [{{ work.work.publication_date }}],
-  [{{ work.citation_resume.type_a_count + work.citation_resume.type_b_count }}],
-  [{{ work.citation_resume.type_a_count }}],
-  [{{ work.citation_resume.type_b_count }}],
+  [{{ work.citation_summary.type_a_count + work.citation_summary.type_b_count }}],
+  [{{ work.citation_summary.type_a_count }}],
+  [{{ work.citation_summary.type_b_count }}],
   [{{ work.work.open_access.oa_status.value }}],
   {% endfor %}
 )

pub_analyzer/internal/templates/author/works_extended.typ

@@ -1,11 +1,10 @@
-== Extended info.
 {% for work in report.works %}
 
 {% if not loop.first %}
 #pagebreak()
 {% endif %}
 
-=== #text()[#"{{ work.work.title.replace('"', '\\"') }}"] <work_{{ loop.index }}>
+== #text()[#"{{ work.work.title.replace('"', '\\"') }}"] <work_{{ loop.index }}>
 
 #linebreak()
 
@@ -39,9 +38,9 @@
   [
     #align(center)[_Citation_]
     #parbreak()
-    - *Count:* {{ work.citation_resume.type_a_count + work.citation_resume.type_b_count }}
-    - *Type A:* {{ work.citation_resume.type_a_count }}
-    - *Type B:* {{ work.citation_resume.type_b_count }}
+    - *Count:* {{ work.citation_summary.type_a_count + work.citation_summary.type_b_count }}
+    - *Type A:* {{ work.citation_summary.type_a_count }}
+    - *Type B:* {{ work.citation_summary.type_b_count }}
   ],
 )
 
@@ -83,7 +82,7 @@
   // Content
   {% for location in work.work.locations %}
   {% if location.source %}
-  [{{ loop.index }}],
+  [#underline([#link(label("source_{{ location.source.id.path.rpartition("/")[2] }}"))[{{ loop.index }}]])],
   [#underline([#link("{{ location.landing_page_url }}")[#"{{ location.source.display_name }}"]])],
   [{{ location.source.host_organization_name or "-" }}],
   [{{ location.source.type }}],

pub_analyzer/main.py

@@ -18,16 +18,17 @@ from pub_analyzer.widgets.sidebar import SideBar
 class PubAnalyzerApp(App[DOMNode]):
     """Pub Analyzer App entrypoint."""
 
+    TITLE = "Pub Analyzer"
+
     CSS_PATH: ClassVar[CSSPathType | None] = [
-        "css/author.tcss",
         "css/body.tcss",
         "css/buttons.tcss",
         "css/checkbox.tcss",
         "css/collapsible.tcss",
         "css/datatable.tcss",
-        "css/institution.tcss",
         "css/main.tcss",
         "css/report.tcss",
+        "css/summary.tcss",
         "css/search.tcss",
         "css/tabs.tcss",
         "css/tree.tcss",
@@ -42,8 +43,12 @@ class PubAnalyzerApp(App[DOMNode]):
 
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
+        footer = Footer()
+        footer.upper_case_keys = True
+        footer.ctrl_to_caret = False
+
         yield Body()
-        yield Footer()
+        yield footer
 
     def action_toggle_dark(self) -> None:
         """Toggle dark mode."""

pub_analyzer/models/author.py

@@ -2,7 +2,7 @@
 
 from typing import TypeAlias
 
-from pydantic import BaseModel, ConfigDict, Field, HttpUrl, field_validator
+from pydantic import BaseModel, Field, HttpUrl
 
 from pub_analyzer.models.institution import DehydratedInstitution
 
@@ -16,19 +16,11 @@ AuthorOpenAlexKey: TypeAlias = str
 class AuthorIDs(BaseModel):
     """IDs from an Author."""
 
-    openalex: str
-    orcid: str | None = ""
-    scopus: str | None = ""
-    twitter: str | None = ""
-    wikipedia: str | None = ""
-
-    # Allowing a value to be assigned during validation.
-    model_config = ConfigDict(validate_assignment=True)
-
-    @field_validator("scopus", "twitter", "wikipedia")
-    def set_default(cls, value: str) -> str:
-        """Define a default text."""
-        return value or ""
+    openalex: AuthorOpenAlexID
+    orcid: HttpUrl | None = None
+    scopus: HttpUrl | None = None
+    twitter: HttpUrl | None = None
+    wikipedia: HttpUrl | None = None
 
 
 class AuthorYearCount(BaseModel):
@@ -60,7 +52,7 @@ class Author(BaseModel):
     works_count: int
     cited_by_count: int
 
-    last_known_institution: DehydratedInstitution | None
+    last_known_institutions: list[DehydratedInstitution]
     counts_by_year: list[AuthorYearCount]
 
     summary_stats: AuthorSummaryStats
@@ -81,16 +73,8 @@ class AuthorResult(BaseModel):
 
     id: AuthorOpenAlexID
     display_name: str
-    hint: str | None = ""
+    hint: str | None = None
     cited_by_count: int
     works_count: int
     entity_type: str
-    external_id: str | None = ""
-
-    # Allowing a value to be assigned during validation.
-    model_config = ConfigDict(validate_assignment=True)
-
-    @field_validator("hint", "external_id")
-    def set_default(cls, value: str) -> str:
-        """Define a default text."""
-        return value or ""
+    external_id: str | None = None

pub_analyzer/models/concept.py

@@ -0,0 +1,19 @@
+"""Concept model from OpenAlex API Schema definition."""
+
+from pydantic import BaseModel, HttpUrl
+
+
+class DehydratedConcept(BaseModel):
+    """Stripped-down Concept Model."""
+
+    id: HttpUrl
+    """The OpenAlex ID for this concept."""
+    display_name: str
+    """The English-language label of the concept."""
+
+    wikidata: HttpUrl
+    """The Wikidata ID for this concept. All OpenAlex concepts are also Wikidata concepts."""
+    level: int
+    """The level in the concept. Lower-level concepts are more general, and higher-level concepts are more specific."""
+    score: float
+    """The strength of the connection between the work and this concept (higher is stronger)."""

pub_analyzer/models/institution.py

@@ -77,6 +77,12 @@ class InstitutionRole(BaseModel):
     works_count: int
 
 
+class International(BaseModel):
+    """The institution's display name in different languages."""
+
+    display_name: dict[str, str]
+
+
 class Institution(BaseModel):
     """Universities and other organizations to which authors claim affiliations."""
 
@@ -87,11 +93,15 @@ class Institution(BaseModel):
     country_code: str
     type: InstitutionType
     homepage_url: HttpUrl | None = None
+    image_url: HttpUrl | None = None
+
+    display_name_acronyms: list[str]
+    international: International
 
     works_count: int
     cited_by_count: int
-    counts_by_year: list[InstitutionYearCount]
     summary_stats: InstitutionSummaryStats
+    counts_by_year: list[InstitutionYearCount]
 
     geo: InstitutionGeo
     roles: list[InstitutionRole]

pub_analyzer/models/report.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel
 
 from .author import Author
 from .institution import Institution
-from .source import DehydratedSource
+from .source import Source
 from .work import OpenAccessStatus, Work
 
 
@@ -24,7 +24,7 @@ class CitationReport(BaseModel):
     citation_type: CitationType
 
 
-class CitationResume(BaseModel):
+class CitationSummary(BaseModel):
     """Summary of citation information in all works."""
 
     type_a_count: int = 0
@@ -38,7 +38,7 @@ class CitationResume(BaseModel):
             self.type_b_count += 1
 
 
-class OpenAccessResume(BaseModel):
+class OpenAccessSummary(BaseModel):
     """Open Access Type counter."""
 
     gold: int = 0
@@ -75,13 +75,13 @@ class WorkReport(BaseModel):
     work: Work
     cited_by: list[CitationReport]
 
-    citation_resume: CitationResume
+    citation_summary: CitationSummary
 
 
-class SourcesResume(BaseModel):
+class SourcesSummary(BaseModel):
     """Sources model with stats."""
 
-    sources: list[DehydratedSource]
+    sources: list[Source]
 
 
 class AuthorReport(BaseModel):
@@ -90,10 +90,10 @@ class AuthorReport(BaseModel):
     author: Author
     works: list[WorkReport]
 
-    citation_resume: CitationResume
-    open_access_resume: OpenAccessResume
-    works_type_resume: list[WorkTypeCounter]
-    sources_resume: SourcesResume
+    citation_summary: CitationSummary
+    open_access_summary: OpenAccessSummary
+    works_type_summary: list[WorkTypeCounter]
+    sources_summary: SourcesSummary
 
 
 class InstitutionReport(BaseModel):
@@ -102,7 +102,7 @@ class InstitutionReport(BaseModel):
     institution: Institution
     works: list[WorkReport]
 
-    citation_resume: CitationResume
-    open_access_resume: OpenAccessResume
-    works_type_resume: list[WorkTypeCounter]
-    sources_resume: SourcesResume
+    citation_summary: CitationSummary
+    open_access_summary: OpenAccessSummary
+    works_type_summary: list[WorkTypeCounter]
+    sources_summary: SourcesSummary

pub_analyzer/models/source.py

@@ -1,21 +1,77 @@
 """Sources models from OpenAlex API Schema definition."""
 
-from pydantic import BaseModel, HttpUrl
+from pydantic import BaseModel, Field, HttpUrl
+
+
+class SourceSummaryStats(BaseModel):
+    """Citation metrics for this Source."""
+
+    two_yr_mean_citedness: float = Field(..., alias="2yr_mean_citedness")
+    """The 2-year mean citedness for this source. Also known as impact factor."""
+    h_index: int
+    """The h-index for this source."""
+    i10_index: int
+    """The i-10 index for this source."""
+
+
+class SourceYearCount(BaseModel):
+    """Summary of published papers and number of citations in a year."""
+
+    year: int
+    """Year."""
+    works_count: int
+    """The number of Works this source hosts in this year."""
+    cited_by_count: int
+    """The total number of Works that cite a Work hosted in this source in this year."""
 
 
 class DehydratedSource(BaseModel):
     """Stripped-down Source Model."""
 
     id: HttpUrl
+    """The OpenAlex ID for this source."""
     display_name: str
+    """The name of the source."""
 
     issn_l: str | None = None
+    """The ISSN-L identifying this source. The ISSN-L designating a single canonical ISSN
+       for all media versions of the title. It's usually the same as the print ISSN.
+    """
     issn: list[str] | None = None
+    """The ISSNs used by this source. An ISSN identifies all continuing resources, irrespective
+       of their medium (print or electronic). [More info](https://www.issn.org/){target=_blank}.
+    """
 
-    is_oa: bool | None = False
-    is_in_doaj: bool | None = False
+    is_oa: bool
+    """Whether this is currently fully-open-access source."""
+    is_in_doaj: bool
+    """Whether this is a journal listed in the [Directory of Open Access Journals](https://doaj.org){target=_blank} (DOAJ)."""
 
     host_organization: HttpUrl | None = None
+    """The host organization for this source as an OpenAlex ID. This will be an
+       [Institution.id][pub_analyzer.models.institution.Institution.id] if the source is a repository,
+       and a Publisher.id if the source is a journal, conference, or eBook platform
+    """
     host_organization_name: str | None = None
+    """The display_name from the host_organization."""
 
     type: str
+    """The type of source, which will be one of: `journal`, `repository`, `conference`,
+       `ebook platform`, or `book series`.
+    """
+
+
+class Source(DehydratedSource):
+    """Where works are hosted."""
+
+    homepage_url: HttpUrl | None = None
+    """The homepage for this source's website."""
+
+    is_in_doaj: bool
+    """Whether this is a journal listed in the Directory of Open Access Journals (DOAJ)."""
+
+    summary_stats: SourceSummaryStats
+    """Citation metrics for this source."""
+
+    counts_by_year: list[SourceYearCount]
+    """works_count and cited_by_count for each of the last ten years, binned by year."""

pub_analyzer/models/topic.py

@@ -0,0 +1,59 @@
+"""Topics models from OpenAlex API Schema definition."""
+
+from pydantic import BaseModel, HttpUrl
+
+
+class TopicIDs(BaseModel):
+    """External identifiers for a Topic."""
+
+    openalex: HttpUrl
+    """The OpenAlex ID for this Topic."""
+    wikipedia: HttpUrl | None = None
+    """This topic's Wikipedia page URL."""
+
+
+class TopicLevel(BaseModel):
+    """Topic level information."""
+
+    id: HttpUrl
+    """ID for the topic level. For more info, consult the
+       [OpenAlex topic mapping table](https://docs.google.com/spreadsheets/d/1v-MAq64x4YjhO7RWcB-yrKV5D_2vOOsxl4u6GBKEXY8/){target=_blank}.
+    """
+    display_name: str
+    """The English-language label of the level."""
+
+
+class DehydratedTopic(BaseModel):
+    """Stripped-down Topic Model."""
+
+    id: HttpUrl
+    """The OpenAlex ID for this Topic."""
+    display_name: str
+    """The English-language label of the topic."""
+    score: float
+    """The strength of the connection between the work and this topic (higher is stronger)."""
+
+    domain: TopicLevel
+    """The highest level in the Topics structure."""
+    field: TopicLevel
+    """The second-highest level in the Topics structure."""
+    subfield: TopicLevel
+    """The third-highest level in the Topics structure."""
+
+
+class Topic(DehydratedTopic):
+    """Labels which can be used to describe what a paper is about."""
+
+    ids: TopicIDs
+    """All the external identifiers for a Topic."""
+    description: str
+    """A description of this topic, generated by AI."""
+    keywords: list[str]
+    """Keywords consisting of one or several words each, meant to represent
+       the content of the papers in the topic.
+    """
+
+    works_count: int
+    """The number of works tagged with this topic."""
+    cited_by_count: int
+    """The number of citations to works that have been tagged with this topic."""

pub_analyzer/models/work.py

@@ -6,7 +6,9 @@ from typing import Any
 from pydantic import BaseModel, HttpUrl, field_validator
 
 from .author import DehydratedAuthor
+from .concept import DehydratedConcept
 from .source import DehydratedSource
+from .topic import DehydratedTopic
 
 
 class WorkIDs(BaseModel):
@@ -72,6 +74,22 @@ class ArticleProcessingCharge(BaseModel):
     value_usd: int | None
 
 
+class Grant(BaseModel):
+    """Grant Model Object from OpenAlex API definition."""
+
+    funder: HttpUrl
+    funder_display_name: str
+    award_id: str | None = None
+
+
+class Keyword(BaseModel):
+    """Keyword extracted from the work's title and confidence score."""
+
+    id: HttpUrl
+    display_name: str
+    score: float
+
+
 class Work(BaseModel):
     """Work Model Object from OpenAlex API definition."""
 
@@ -97,6 +115,11 @@ class Work(BaseModel):
        To use a verified number that respects the applied filters use [WorkReport][pub_analyzer.models.report.WorkReport].
     """
 
+    grants: list[Grant]
+    keywords: list[Keyword]
+    concepts: list[DehydratedConcept]
+    topics: list[DehydratedTopic]
+
     referenced_works: list[HttpUrl]
     cited_by_api_url: HttpUrl
 

pub_analyzer/widgets/author/cards.py

@@ -54,11 +54,12 @@ class LastInstitutionCard(Card):
         """Compose card."""
         yield Label("[italic]Last Institution:[/italic]", classes="card-title")
 
-        if self.author.last_known_institution:
-            ror = self.author.last_known_institution.ror
-            institution_name = self.author.last_known_institution.display_name
+        if self.author.last_known_institutions:
+            last_known_institution = self.author.last_known_institutions[0]
+            ror = last_known_institution.ror
+            institution_name = last_known_institution.display_name
 
             with Vertical(classes="card-container"):
                 yield Label(f"""[bold]Name:[/bold] [@click=app.open_link('{quote(str(ror))}')]{institution_name}[/]""")
-                yield Label(f"[bold]Country:[/bold] {self.author.last_known_institution.country_code}")
-                yield Label(f"[bold]Type:[/bold] {self.author.last_known_institution.type.value}")
+                yield Label(f"[bold]Country:[/bold] {last_known_institution.country_code}")
+                yield Label(f"[bold]Type:[/bold] {last_known_institution.type.value}")