pub-analyzer 0.5.6__py3-none-any.whl

pub_analyzer/widgets/common/input.py

@@ -0,0 +1,97 @@
+"""Input widgets."""
+
+import re
+from collections.abc import Iterable
+
+from rich.highlighter import Highlighter
+from textual import on
+from textual.events import Key
+from textual.suggester import Suggester
+from textual.validation import Regex, Validator
+from textual.widgets import Input as TextualInput
+
+
+class Input(TextualInput):
+    """Input with extra bindings."""
+
+    DEFAULT_CSS = """
+    /* COLORS */
+    $primary-color: #b91c1c;
+    $primary-color-accent: #991b1b;
+    $primary-color-highlight: #dc2626;
+
+    Input {
+        border: tall $background;
+    }
+
+    Input:focus {
+        border: tall $primary-color-accent;
+    }
+    Input.-invalid {
+        border: tall orange 40%;
+    }
+    Input.-invalid:focus {
+        border: tall orange 60%;
+    }
+    """
+
+    @on(Key)
+    def exit_focus(self, event: Key) -> None:
+        """Unfocus from the input with esc KEY."""
+        if event.key == "escape":
+            self.screen.set_focus(None)
+
+
+class DateSuggester(Suggester):
+    """Suggest date format."""
+
+    async def get_suggestion(self, value: str) -> str | None:
+        """Gets a completion as of the current input date."""
+        if match := re.match(r"^(?P<year>\d{1,4})(-|$)(?P<month>\d{1,2})?(-|$)(?P<day>\d{1,2})?$", value):
+            date_comp = match.groupdict()
+
+            year = date_comp["year"] or "yyyy"
+            month = date_comp["month"] or "mm"
+            day = date_comp["day"] or "dd"
+
+            return f"{year}-{month}-{day}"
+        return None
+
+
+class DateInput(Input):
+    """Input with Date validation."""
+
+    def __init__(
+        self,
+        value: str | None = None,
+        placeholder: str = "",
+        highlighter: Highlighter | None = None,
+        password: bool = False,
+        *,
+        validators: Validator | Iterable[Validator] | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        suggester = DateSuggester()
+
+        super().__init__(
+            value,
+            placeholder,
+            highlighter,
+            password,
+            suggester=suggester,
+            validators=validators,
+            name=name,
+            id=id,
+            classes=classes,
+            disabled=disabled,
+        )
+
+        self.validators.append(
+            Regex(
+                regex=r"^(?P<year>\d{4})-((?P<longMonth>(0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))|(?P<shortMonth>(0[469]|11)-(0[1-9]|[12][0-9]|30))|(?P<februaryMonth>(02)-([01][1-9]|[2][0-8])))$",
+                failure_description="Input must be formatted as `yyyy-mm-dd`",
+            )
+        )

pub_analyzer/widgets/common/label.py

@@ -0,0 +1,36 @@
+"""Label widget but with reactivity enable."""
+
+from rich.console import RenderableType
+from rich.text import Text
+from textual.app import RenderResult
+from textual.reactive import reactive
+from textual.widget import Widget
+
+
+class ReactiveLabel(Widget):
+    """A Label widget but with reactivity enable."""
+
+    renderable: reactive[RenderableType] = reactive[RenderableType]("", layout=True)
+
+    def __init__(
+        self,
+        renderable: RenderableType = "",
+        markup: bool = True,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ):
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+        self.markup = markup
+        self.renderable = renderable
+
+    def render(self) -> RenderResult:
+        """Render widget."""
+        if isinstance(self.renderable, str):
+            if self.markup:
+                return Text.from_markup(self.renderable)
+            else:
+                return Text(self.renderable)
+        else:
+            return self.renderable

pub_analyzer/widgets/common/modal.py

@@ -0,0 +1,43 @@
+"""Modal Screen."""
+
+from textual.screen import Screen, ScreenResultType
+
+
+class Modal(Screen[ScreenResultType]):
+    """Base overlay window container."""
+
+    DEFAULT_CSS = """
+    $bg-main-color: white;
+    $bg-secondary-color: #e5e7eb;
+    $text-primary-color: black;
+
+    $text-primary-color-darken: black;
+
+    Modal {
+        background: rgba(229, 231, 235, 0.5);
+        align: center middle;
+    }
+
+    Modal #dialog {
+        background: $bg-main-color;
+        height: 100%;
+        width: 100%;
+
+        margin: 3 10;
+        border: $bg-secondary-color;
+    }
+
+    .-dark-mode Modal #dialog {
+        background: $bg-secondary-color;
+        color: $text-primary-color-darken;
+    }
+
+    Modal #dialog .dialog-title {
+        height: 3;
+        width: 100%;
+        margin: 1;
+
+        text-align: center;
+        border-bottom: solid $text-primary-color;
+    }
+    """

pub_analyzer/widgets/common/selector.py

@@ -0,0 +1,66 @@
+"""Custom Selector widget."""
+
+from typing import TypeVar
+
+from textual import on
+from textual.events import Key
+from textual.widgets import Select as TextualSelect
+
+SelectType = TypeVar("SelectType")
+
+
+class Select(TextualSelect[SelectType]):
+    """Widget to select from a list of possible options."""
+
+    DEFAULT_CSS = """
+    /* COLORS */
+    $primary-color: #b91c1c;
+    $primary-color-accent: #991b1b;
+    $primary-color-highlight: #dc2626;
+
+    $bg-secondary-color: #e5e7eb;
+
+    Select {
+        height: 3;
+    }
+
+    Select:focus > SelectCurrent {
+        border: tall $primary-color-accent;
+    }
+
+    Select.-expanded > SelectCurrent {
+        border: tall $primary-color-accent;
+    }
+
+    SelectOverlay {
+        border: tall $bg-secondary-color;
+        background: $bg-secondary-color;
+    }
+
+    SelectOverlay:focus {
+        border: tall $bg-secondary-color;
+    }
+
+    Select OptionList {
+        background: $bg-secondary-color;
+    }
+
+
+    Select OptionList:focus > .option-list--option-highlighted {
+        background: $primary-color;
+    }
+
+    Select OptionList > .option-list--option-hover-highlighted {
+        background: $primary-color-accent;
+    }
+
+    Select OptionList:focus > .option-list--option-hover-highlighted {
+        background: $primary-color-accent;
+    }
+    """
+
+    @on(Key)
+    def exit_focus(self, event: Key) -> None:
+        """Unfocus from the input with esc KEY."""
+        if event.key == "escape":
+            self.screen.set_focus(None)

pub_analyzer/widgets/common/summary.py

@@ -0,0 +1,7 @@
+"""Common Summary format Widget."""
+
+from textual.containers import VerticalScroll
+
+
+class SummaryWidget(VerticalScroll):
+    """Common format summary container."""

pub_analyzer/widgets/institution/__init__.py

@@ -0,0 +1 @@
+"""Institution Widgets."""

pub_analyzer/widgets/institution/cards.py

@@ -0,0 +1,78 @@
+"""Institution Cards Widgets."""
+
+from urllib.parse import quote
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Label
+
+from pub_analyzer.models.institution import Institution
+from pub_analyzer.widgets.common import Card
+
+
+class CitationMetricsCard(Card):
+    """Citation metrics for this institution."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Citation metrics:[/italic]", classes="card-title")
+
+        with Vertical(classes="card-container"):
+            yield Label(f"[bold]2-year mean:[/bold] {self.institution.summary_stats.two_yr_mean_citedness:.5f}")
+            yield Label(f"[bold]h-index:[/bold] {self.institution.summary_stats.h_index}")
+            yield Label(f"[bold]i10 index:[/bold] {self.institution.summary_stats.i10_index}")
+
+
+class IdentifiersCard(Card):
+    """Card with external identifiers that we know about this institution."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Identifiers:[/italic]", classes="card-title")
+
+        for platform, platform_url in self.institution.ids.model_dump().items():
+            if platform_url:
+                yield Label(f"""- [@click=app.open_link('{quote(str(platform_url))}')]{platform}[/]""")
+
+        if self.institution.homepage_url:
+            yield Label(f"""- [@click=app.open_link('{quote(str(self.institution.homepage_url))}')]Homepage[/]""")
+
+
+class GeoCard(Card):
+    """Card with location info of this institution."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Geo:[/italic]", classes="card-title")
+
+        with Vertical(classes="card-container"):
+            yield Label(f"[bold]City:[/bold] {self.institution.geo.city}")
+            yield Label(f"[bold]Country:[/bold] {self.institution.geo.country}")
+
+
+class RolesCard(Card):
+    """Card with roles info of this institution."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Works by roles:[/italic]", classes="card-title")
+
+        with Vertical(classes="card-container"):
+            for role in self.institution.roles:
+                yield Label(f"""[@click=app.open_link('{quote(str(role.id))}')]{role.role.value.title()}[/]: {role.works_count}""")

pub_analyzer/widgets/institution/core.py

@@ -0,0 +1,122 @@
+"""Module with Widgets that allows to display the complete information of Institution using OpenAlex."""
+
+from typing import Any
+
+import httpx
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import Button, Collapsible, Label, Static
+
+from pub_analyzer.internal.identifier import get_institution_id
+from pub_analyzer.models.institution import Institution, InstitutionResult
+from pub_analyzer.widgets.common.filters import DateRangeFilter, Filter
+from pub_analyzer.widgets.common.summary import SummaryWidget
+from pub_analyzer.widgets.report.core import CreateInstitutionReportWidget
+
+from .cards import CitationMetricsCard, IdentifiersCard, RolesCard
+from .tables import InstitutionWorksByYearTable
+
+
+class _InstitutionSummaryWidget(Static):
+    """Institution info summary."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose institution info."""
+        is_report_not_available = self.institution.works_count < 1
+
+        # Compose Cards
+        with Vertical(classes="block-container"):
+            yield Label("[bold]Institution info:[/bold]", classes="block-title")
+
+            with Horizontal(classes="cards-container"):
+                yield RolesCard(institution=self.institution)
+                yield IdentifiersCard(institution=self.institution)
+                yield CitationMetricsCard(institution=self.institution)
+
+        # Work related info
+        with Vertical(classes="block-container"):
+            yield Label("[bold]Work Info:[/bold]", classes="block-title")
+
+            with Horizontal(classes="info-container"):
+                yield Label(f"[bold]Cited by count:[/bold] {self.institution.cited_by_count}")
+                yield Label(f"[bold]Works count:[/bold] {self.institution.works_count}")
+
+        # Count by year table section
+        with Container(classes="table-container"):
+            yield InstitutionWorksByYearTable(institution=self.institution)
+
+        # Make report section
+        with Vertical(classes="block-container", disabled=is_report_not_available):
+            yield Label("[bold]Make report:[/bold]", classes="block-title")
+
+            # Filters
+            with Collapsible(title="Report filters.", classes="filter-collapsible"):
+                # Institution publication Date Range
+                yield DateRangeFilter(checkbox_label="Publication date range:", id="institution-date-range-filter")
+
+                # Cite Date Range
+                yield DateRangeFilter(checkbox_label="Cited date range:", id="cited-date-range-filter")
+
+            # Button
+            with Vertical(classes="block-container button-container"):
+                yield Button("Make Report", variant="primary", id="make-report-button")
+
+
+class InstitutionSummaryWidget(SummaryWidget):
+    """Institution info summary container."""
+
+    def __init__(self, institution_result: InstitutionResult) -> None:
+        self.institution_result = institution_result
+        self.institution: Institution
+        super().__init__()
+
+    def on_mount(self) -> None:
+        """Hide the empty container and call data in the background."""
+        self.loading = True
+        self.run_worker(self.load_data(), exclusive=True)
+
+    async def _get_info(self) -> None:
+        """Query OpenAlex API."""
+        institution_id = get_institution_id(self.institution_result)
+        url = f"https://api.openalex.org/institutions/{institution_id}"
+
+        async with httpx.AsyncClient() as client:
+            results = (await client.get(url)).json()
+            self.institution = Institution(**results)
+
+    async def load_data(self) -> None:
+        """Query OpenAlex API and composing the widget."""
+        await self._get_info()
+        await self.mount(_InstitutionSummaryWidget(institution=self.institution))
+
+        self.loading = False
+
+    @on(Filter.Changed)
+    def filter_change(self) -> None:
+        """Handle filter changes."""
+        filters = [filter for filter in self.query("_InstitutionSummaryWidget Filter").results(Filter) if not filter.filter_disabled]
+        all_filters_valid = all(filter.validation_state for filter in filters)
+
+        self.query_one("_InstitutionSummaryWidget #make-report-button", Button).disabled = not all_filters_valid
+
+    @on(Button.Pressed, "#make-report-button")
+    async def make_report(self) -> None:
+        """Make the author report."""
+        filters: dict[str, Any] = {}
+        pub_date_range = self.query_one("#institution-date-range-filter", DateRangeFilter)
+        cited_date_range = self.query_one("#cited-date-range-filter", DateRangeFilter)
+
+        if not pub_date_range.filter_disabled:
+            filters.update({"pub_from_date": pub_date_range.from_date, "pub_to_date": pub_date_range.to_date})
+
+        if not cited_date_range.filter_disabled:
+            filters.update({"cited_from_date": cited_date_range.from_date, "cited_to_date": cited_date_range.to_date})
+
+        report_widget = CreateInstitutionReportWidget(institution=self.institution, **filters)
+        await self.app.query_one("MainContent").mount(report_widget)
+        await self.app.query_one("InstitutionSummaryWidget").remove()

pub_analyzer/widgets/institution/tables.py

@@ -0,0 +1,24 @@
+"""Institution Tables Widgets."""
+
+from rich.table import Table
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.institution import Institution
+
+
+class InstitutionWorksByYearTable(Static):
+    """Table with Work count and cited by count of the last 10 years."""
+
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        table = Table("Year", "Works Count", "Cited by Count", title="Counts by Year", expand=True)
+        for row in self.institution.counts_by_year:
+            year, works_count, cited_by_count = row.model_dump().values()
+            table.add_row(str(year), str(works_count), str(cited_by_count))
+
+        yield Static(table)

pub_analyzer/widgets/report/__init__.py

@@ -0,0 +1 @@
+"""Widgets for summarizing and generating reports."""

pub_analyzer/widgets/report/author.py

@@ -0,0 +1,43 @@
+"""Author Report Widgets."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import TabbedContent, TabPane
+
+from pub_analyzer.models.report import AuthorReport
+from pub_analyzer.widgets.author.cards import CitationMetricsCard, IdentifiersCard, LastInstitutionCard
+from pub_analyzer.widgets.author.tables import AffiliationsTable, AuthorWorksByYearTable
+
+
+class AuthorReportPane(VerticalScroll):
+    """Work report Pane Widget."""
+
+    DEFAULT_CSS = """
+    AuthorReportPane {
+        layout: vertical;
+        overflow-x: hidden;
+        overflow-y: auto;
+
+        .author-tables-container {
+            margin: 1 0 0 0 ;
+            height: auto;
+        }
+    }
+    """
+
+    def __init__(self, report: AuthorReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose content pane."""
+        with Horizontal(classes="cards-container"):
+            yield LastInstitutionCard(author=self.report.author)
+            yield IdentifiersCard(author=self.report.author)
+            yield CitationMetricsCard(author=self.report.author)
+
+        with TabbedContent(id="author-tables-container"):
+            with TabPane("Citation Metrics"):
+                yield AuthorWorksByYearTable(author=self.report.author)
+            with TabPane("Institutions"):
+                yield AffiliationsTable(author=self.report.author)

pub_analyzer/widgets/report/cards.py

@@ -0,0 +1,130 @@
+"""Report Cards Widgets."""
+
+from urllib.parse import quote
+
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Label
+
+from pub_analyzer.models.author import Author
+from pub_analyzer.models.report import AuthorReport, InstitutionReport, WorkReport
+from pub_analyzer.models.work import Work
+from pub_analyzer.widgets.common import Card
+
+
+# Works pane cards.
+class ReportCitationMetricsCard(Card):
+    """Citation metrics for this report."""
+
+    def __init__(self, report: AuthorReport | InstitutionReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Citation metrics:[/italic]", classes="card-title")
+
+        with Vertical(classes="card-container"):
+            type_a_count = self.report.citation_summary.type_a_count
+            type_b_count = self.report.citation_summary.type_b_count
+            cited_by_count = type_a_count + type_b_count
+
+            yield Label(f"[bold]Count:[/bold] {cited_by_count}")
+            yield Label(f"[bold]Type A:[/bold] {type_a_count}")
+            yield Label(f"[bold]Type B:[/bold] {type_b_count}")
+
+
+class WorksTypeSummaryCard(Card):
+    """Works Type Counters Summary Card."""
+
+    def __init__(self, report: AuthorReport | InstitutionReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Work Type[/italic]", classes="card-title")
+
+        with VerticalScroll(classes="card-container"):
+            for work_type_counter in self.report.works_type_summary:
+                yield Label(f"[bold]{work_type_counter.type_name}:[/bold] {work_type_counter.count}")
+
+
+class OpenAccessSummaryCard(Card):
+    """Open Access counts for this report."""
+
+    def __init__(self, report: AuthorReport | InstitutionReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Open Access[/italic]", classes="card-title")
+
+        with VerticalScroll(classes="card-container"):
+            for status, count in self.report.open_access_summary.model_dump().items():
+                yield Label(f"[bold]{status.capitalize()}:[/bold] {count}")
+
+
+# Work Info cards.
+class AuthorshipCard(Card):
+    """Card that enumerate the authorship's of a work."""
+
+    def __init__(self, work: Work, author: Author | None) -> None:
+        self.work = work
+        self.author = author
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Authorship's[/italic]", classes="card-title")
+
+        with VerticalScroll(classes="card-container"):
+            for authorship in self.work.authorships:
+                # If the author was provided, highlight
+                if self.author and authorship.author.display_name == self.author.display_name:
+                    author_name_formated = f"[b #909d63]{authorship.author.display_name}[/]"
+                else:
+                    author_name_formated = str(authorship.author.display_name)
+
+                external_id = authorship.author.orcid or authorship.author.id
+                yield Label(
+                    f"""- [b]{authorship.author_position}:[/b] [@click=app.open_link('{quote(str(external_id))}')]{author_name_formated}[/]"""  # noqa: E501
+                )
+
+
+class OpenAccessCard(Card):
+    """Card that show OpenAccess status of a work."""
+
+    def __init__(self, work: Work) -> None:
+        self.work = work
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        work_url = self.work.open_access.oa_url
+
+        yield Label("[italic]Open Access[/italic]", classes="card-title")
+        yield Label(f"[bold]Status:[/bold] {self.work.open_access.oa_status.value.capitalize()}")
+        if work_url:
+            yield Label(f"""[bold]URL:[/bold] [@click=app.open_link('{quote(str(work_url))}')]{work_url}[/]""")
+
+
+class CitationMetricsCard(Card):
+    """Card that show Citation metrics of a work."""
+
+    def __init__(self, work_report: WorkReport) -> None:
+        self.work_report = work_report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        type_a_count = self.work_report.citation_summary.type_a_count
+        type_b_count = self.work_report.citation_summary.type_b_count
+        cited_by_count = type_a_count + type_b_count
+
+        yield Label("[italic]Citation[/italic]", classes="card-title")
+
+        yield Label(f"[bold]Count:[/bold] {cited_by_count}")
+        yield Label(f"[bold]Type A:[/bold] {type_a_count}")
+        yield Label(f"[bold]Type B:[/bold] {type_b_count}")