pub-analyzer 0.5.6__py3-none-any.whl

pub_analyzer/widgets/author/cards.py

@@ -0,0 +1,65 @@
+"""Author 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.author import Author
+from pub_analyzer.widgets.common import Card
+
+
+class CitationMetricsCard(Card):
+    """Citation metrics for this author."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        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.author.summary_stats.two_yr_mean_citedness:.5f}")
+            yield Label(f"[bold]h-index:[/bold] {self.author.summary_stats.h_index}")
+            yield Label(f"[bold]i10 index:[/bold] {self.author.summary_stats.i10_index}")
+
+
+class IdentifiersCard(Card):
+    """Card with external identifiers that we know about for this author."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Identifiers:[/italic]", classes="card-title")
+
+        for platform, platform_url in self.author.ids.model_dump().items():
+            if platform_url:
+                yield Label(f"""- [@click=app.open_link('{quote(str(platform_url))}')]{platform}[/]""")
+
+
+class LastInstitutionCard(Card):
+    """Card with author's last known institutional affiliation."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose card."""
+        yield Label("[italic]Last Institution:[/italic]", classes="card-title")
+
+        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] {last_known_institution.country_code}")
+                yield Label(f"[bold]Type:[/bold] {last_known_institution.type.value}")

pub_analyzer/widgets/author/core.py

@@ -0,0 +1,122 @@
+"""Module with Widgets that allows to display the complete information of an Author 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_author_id
+from pub_analyzer.models.author import Author, AuthorResult
+from pub_analyzer.widgets.common.filters import DateRangeFilter, Filter
+from pub_analyzer.widgets.common.summary import SummaryWidget
+from pub_analyzer.widgets.report.core import CreateAuthorReportWidget
+
+from .cards import CitationMetricsCard, IdentifiersCard, LastInstitutionCard
+from .tables import AuthorWorksByYearTable
+
+
+class _AuthorSummaryWidget(Static):
+    """Author info summary."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose author info."""
+        is_report_not_available = self.author.works_count < 1
+
+        # Compose Cards
+        with Vertical(classes="block-container"):
+            yield Label("[bold]Author info:[/bold]", classes="block-title")
+
+            with Horizontal(classes="cards-container"):
+                yield LastInstitutionCard(author=self.author)
+                yield IdentifiersCard(author=self.author)
+                yield CitationMetricsCard(author=self.author)
+
+        # 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.author.cited_by_count}")
+                yield Label(f"[bold]Works count:[/bold] {self.author.works_count}")
+
+        # Count by year table section
+        with Container(classes="table-container"):
+            yield AuthorWorksByYearTable(author=self.author)
+
+        # 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"):
+                # Author publication Date Range
+                yield DateRangeFilter(checkbox_label="Publication date range:", id="author-date-range-filter")
+
+                # Cite Date Range
+                yield DateRangeFilter(checkbox_label="Cited date range:", id="cited-date-range-filter")
+
+            # Button
+            with Vertical(classes="button-container"):
+                yield Button("Make Report", variant="primary", id="make-report-button")
+
+
+class AuthorSummaryWidget(SummaryWidget):
+    """Author info summary container."""
+
+    def __init__(self, author_result: AuthorResult) -> None:
+        self.author_result = author_result
+        self.author: Author
+        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."""
+        author_id = get_author_id(self.author_result)
+        url = f"https://api.openalex.org/authors/{author_id}"
+
+        async with httpx.AsyncClient() as client:
+            results = (await client.get(url)).json()
+            self.author = Author(**results)
+
+    async def load_data(self) -> None:
+        """Query OpenAlex API and composing the widget."""
+        await self._get_info()
+        await self.mount(_AuthorSummaryWidget(author=self.author))
+
+        self.loading = False
+
+    @on(Filter.Changed)
+    def filter_change(self) -> None:
+        """Handle filter changes."""
+        filters = [filter for filter in self.query("_AuthorSummaryWidget Filter").results(Filter) if not filter.filter_disabled]
+        all_filters_valid = all(filter.validation_state for filter in filters)
+
+        self.query_one("_AuthorSummaryWidget #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("#author-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 = CreateAuthorReportWidget(author=self.author, **filters)
+        await self.app.query_one("MainContent").mount(report_widget)
+        await self.app.query_one("AuthorSummaryWidget").remove()

pub_analyzer/widgets/author/tables.py

@@ -0,0 +1,50 @@
+"""Author Tables Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.author import Author
+
+
+class AuthorWorksByYearTable(Static):
+    """Table with Work count and cited by count of the last 10 years."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        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.author.counts_by_year[:-11:-1]:
+            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)
+
+
+class AffiliationsTable(Static):
+    """Table with all the institutions to which an author has been affiliated."""
+
+    def __init__(self, author: Author) -> None:
+        self.author = author
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        table = Table("Institution", "Country", "Type", "Years", title="Affiliations", expand=True, show_lines=True)
+        for affiliation in self.author.affiliations:
+            institution = affiliation.institution
+            institution_name = (
+                f"""[@click=app.open_link("{quote(str(institution.ror))}")]{institution.display_name}[/]"""
+                if institution.ror
+                else f"{institution.display_name}"
+            )
+            years = ",".join([str(year) for year in affiliation.years])
+            country_code = institution.country_code.upper() if institution.country_code else "-"
+            table.add_row(str(institution_name), str(country_code), str(institution.type.name), str(years))
+
+        yield Static(table)

pub_analyzer/widgets/body.py

@@ -0,0 +1,55 @@
+"""Body components."""
+
+from rich.console import RenderableType
+from textual import on
+from textual.app import ComposeResult
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Label, Static
+
+from pub_analyzer.widgets.search import FinderWidget
+from pub_analyzer.widgets.sidebar import SideBar
+
+
+class MainContent(Static):
+    """Main content Widget."""
+
+    DEFAULT_CLASSES = "main-content"
+
+    class UpdateMainContent(Message):
+        """New main content required."""
+
+        def __init__(self, new_widget: Widget, title: str | None) -> None:
+            self.widget = new_widget
+            self.title = title
+            super().__init__()
+
+    def __init__(self, title: str = "Title") -> None:
+        self.title = title
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose dynamically the main content view."""
+        yield Label(self.title, classes="title", id="page-title")
+        yield FinderWidget()
+
+    def update_title(self, title: RenderableType) -> None:
+        """Update view title."""
+        self.query_one("#page-title", Label).update(title)
+
+    @on(UpdateMainContent)
+    async def update_content(self, new_content: UpdateMainContent) -> None:
+        """Replace the main content."""
+        await self.query_children().exclude("#page-title").remove()
+        if new_content.title:
+            self.update_title(new_content.title)
+        await self.mount(new_content.widget)
+
+
+class Body(Static):
+    """Body App."""
+
+    def compose(self) -> ComposeResult:
+        """Body App."""
+        yield SideBar()
+        yield MainContent(title="Search")

pub_analyzer/widgets/common/__init__.py

@@ -0,0 +1,18 @@
+"""Base Widgets."""
+
+from .card import Card
+from .filesystem import FileSystemSelector
+from .input import DateInput, Input
+from .label import ReactiveLabel
+from .modal import Modal
+from .selector import Select
+
+__all__ = [
+    "Card",
+    "DateInput",
+    "FileSystemSelector",
+    "Input",
+    "Modal",
+    "ReactiveLabel",
+    "Select",
+]

pub_analyzer/widgets/common/card.py

@@ -0,0 +1,29 @@
+"""Card Widget."""
+
+from textual.widgets import Static
+
+
+class Card(Static):
+    """Container for short, related pieces of content displayed in a box."""
+
+    DEFAULT_CLASSES = "card"
+    DEFAULT_CSS = """
+    $bg-secondary-color: #e5e7eb;
+    $text-primary-color: black;
+
+    Card {
+        layout: vertical;
+        height: 100%;
+
+        padding: 1 2;
+        border: solid $text-primary-color;
+        background: $bg-secondary-color;
+    }
+
+    Card > .card-title {
+        margin: 0 0 1 0;
+        width: 100%;
+        text-align: center;
+        border-bottom: solid black;
+    }
+    """

pub_analyzer/widgets/common/filesystem.py

@@ -0,0 +1,203 @@
+"""FileSystem Selector widgets."""
+
+from collections.abc import Iterable
+from enum import Enum, auto
+from pathlib import Path
+
+from rich.console import RenderableType
+from rich.text import Text
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Button, DirectoryTree, Label, Static, Tree
+from textual.widgets._directory_tree import DirEntry
+
+from .modal import Modal
+
+
+class PathTypeSelector(Enum):
+    """Expected path type to be selected."""
+
+    FILE = auto()
+    DIRECTORY = auto()
+
+
+class FilteredDirectoryTree(DirectoryTree):
+    """Directory Tree filtered."""
+
+    def __init__(
+        self, path: str | Path, *, show_hidden_paths: bool = False, only_dir: bool = False, extension: list[str] | None = None
+    ) -> None:
+        self.show_hidden_paths = show_hidden_paths
+        self.only_dir = only_dir
+        self.extension = extension
+        super().__init__(path)
+
+    def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
+        """Filter paths with parameters specified in the class."""
+        final_paths: list[Path] = []
+        for path in paths:
+            # Filter in case show hidden paths are not enable.
+            if not self.show_hidden_paths and path.name.startswith("."):
+                continue
+
+            # Filter in case path type expected is directory.
+            if path.is_file() and self.only_dir:
+                continue
+
+            # Filter in case file extension is expected
+            if path.is_file() and self.extension and path.suffix not in self.extension:
+                continue
+
+            final_paths.append(path)
+
+        return final_paths
+
+
+class PathSelectorModal(Modal[Path | None]):
+    """Export modal confirmation."""
+
+    DEFAULT_CSS = """
+    $bg-main-color: white;
+    $bg-secondary-color: #e5e7eb;
+
+    PathSelectorModal FilteredDirectoryTree {
+        background: $bg-main-color;
+        width: 100%;
+        margin: 0 2;
+    }
+
+    .-dark-mode PathSelectorModal FilteredDirectoryTree {
+        background: $bg-secondary-color;
+    }
+
+    PathSelectorModal .button-container {
+        height: 5;
+        align: center middle;
+    }
+    """
+
+    def __init__(
+        self, path: str | Path, show_hidden_paths: bool = False, only_dir: bool = False, extension: list[str] | None = None
+    ) -> None:
+        self.path = path
+        self.show_hidden_paths = show_hidden_paths
+        self.only_dir = only_dir
+        self.extension = extension
+
+        self.path_selected: Path | None = None
+        super().__init__()
+
+    @on(events.Key)
+    def exit_modal(self, message: events.Key) -> None:
+        """Exit from the modal with esc KEY."""
+        if message.key == "escape":
+            self.app.pop_screen()
+
+    @on(Button.Pressed, "#done-button")
+    def done_button(self) -> None:
+        """Done button."""
+        self.dismiss(self.path_selected)
+
+    @on(DirectoryTree.FileSelected)
+    def update_path_selected_for_file(self, event: DirectoryTree.FileSelected) -> None:
+        """Update file selected."""
+        if not self.only_dir:
+            self.path_selected = event.path
+            self.query_one("#done-button", Button).disabled = False
+
+    @on(Tree.NodeHighlighted)
+    def update_path_selected_for_dir(self, event: Tree.NodeHighlighted[DirEntry]) -> None:
+        """Update file selected."""
+        if self.only_dir and event.node and event.node.data:
+            self.path_selected = event.node.data.path
+            self.query_one("#done-button", Button).disabled = False
+
+    def compose(self) -> ComposeResult:
+        """Compose Modal."""
+        with VerticalScroll(id="dialog"):
+            yield Label("Export Path", classes="dialog-title")
+            yield FilteredDirectoryTree(
+                path=self.path, show_hidden_paths=self.show_hidden_paths, only_dir=self.only_dir, extension=self.extension
+            )
+
+            with Horizontal(classes="button-container"):
+                yield Button("Done", variant="primary", disabled=True, id="done-button")
+
+
+class PathSelectedBox(Widget):
+    """Path selected box."""
+
+    DEFAULT_CSS = """
+    PathSelectedBox {
+        height: 3;
+        width: 100%;
+
+        background: $boost;
+        color: $text;
+
+        padding: 0 2;
+        border: tall $background;
+    }
+    """
+
+    path_selected: reactive[str] = reactive("...", layout=True)
+
+    class Selected(Message):
+        """Selected message."""
+
+    def on_click(self) -> None:
+        """Post message on click."""
+        self.post_message(self.Selected())
+
+    def render(self) -> RenderableType:
+        """Render path selected box."""
+        return Text(self.path_selected, overflow="ellipsis")
+
+
+class FileSystemSelector(Static):
+    """File System selector widget."""
+
+    class FileSelected(Message):
+        """File Selected Message."""
+
+        def __init__(self, file_selected: Path | None) -> None:
+            self.file_selected = file_selected
+            super().__init__()
+
+    def __init__(
+        self, path: str | Path, show_hidden_paths: bool = False, only_dir: bool = False, extension: list[str] | None = None
+    ) -> None:
+        self.path = path
+        self.show_hidden_paths = show_hidden_paths
+        self.only_dir = only_dir
+        self.extension = extension
+
+        self.path_selected: Path | None = None
+        super().__init__()
+
+    @on(PathSelectedBox.Selected)
+    async def show_export_report_modal(self) -> None:
+        """Show export Modal."""
+
+        def update_file_selected(path: Path | None) -> None:
+            """Call when modal is closed."""
+            self.path_selected = path
+            if path:
+                self.query_one(PathSelectedBox).path_selected = path.as_posix()
+                self.post_message(self.FileSelected(file_selected=path))
+            else:
+                self.query_one(PathSelectedBox).path_selected = "..."
+                self.post_message(self.FileSelected(file_selected=path))
+
+        await self.app.push_screen(
+            PathSelectorModal(path=self.path, show_hidden_paths=self.show_hidden_paths, only_dir=self.only_dir, extension=self.extension),
+            callback=update_file_selected,
+        )
+
+    def compose(self) -> ComposeResult:
+        """Compose file system selector."""
+        yield PathSelectedBox()

pub_analyzer/widgets/common/filters.py

@@ -0,0 +1,111 @@
+"""Filters selectors for OpenAlex API."""
+
+from datetime import datetime
+
+from rich.console import RenderableType
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.reactive import reactive, var
+from textual.widgets import Checkbox, Static
+
+from .input import DateInput
+
+
+class Filter(Static):
+    """Base filter."""
+
+    class Changed(Message):
+        """Posted when any input in the filter changes."""
+
+    filter_disabled: reactive[bool] = reactive(True)
+    """Is filter inputs disabled?"""
+
+    @property
+    def validation_state(self) -> bool:
+        """Return true if all validation passes."""
+        raise NotImplementedError
+
+
+class DateRangeFilter(Filter):
+    """Date range selector."""
+
+    DEFAULT_CSS = """
+    DateRangeFilter {
+        height: auto;
+        layout: horizontal;
+    }
+
+    DateRangeFilter Checkbox {
+        width: 1fr;
+    }
+
+    DateRangeFilter .filter-inputs {
+        height: auto;
+        width: 3fr;
+    }
+
+    DateRangeFilter DateInput {
+        width: 1fr;
+    }
+    """
+
+    from_date: var[datetime | None] = var(None)
+    to_date: var[datetime | None] = var(None)
+
+    def __init__(
+        self,
+        checkbox_label: str = "Date Range",
+        renderable: RenderableType = "",
+        *,
+        expand: bool = False,
+        shrink: bool = False,
+        markup: bool = True,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        self.checkbox_label = checkbox_label
+        super().__init__(renderable, expand=expand, shrink=shrink, markup=markup, name=name, id=id, classes=classes, disabled=disabled)
+
+    def compose(self) -> ComposeResult:
+        """Compose Date range selector."""
+        yield Checkbox(self.checkbox_label, value=False, id="filter-checkbox")
+        with Horizontal(classes="filter-inputs", disabled=True):
+            yield DateInput(placeholder="From yyyy-mm-dd", id="from-date")
+            yield DateInput(placeholder="To yyyy-mm-dd", id="to-date")
+
+    def watch_filter_disabled(self, is_filter_disabled: bool) -> None:
+        """Toggle filter disable status with the reactive attribute."""
+        self.query_one(".filter-inputs", Horizontal).disabled = is_filter_disabled
+
+    @property
+    def validation_state(self) -> bool:
+        """Return true if all datetime inputs are correctly formatted."""
+        return all([self.from_date, self.to_date])
+
+    @on(Checkbox.Changed)
+    def toggle_filter_disabled(self, event: Checkbox.Changed) -> None:
+        """Toggle filter enabled status."""
+        event.stop()
+        self.post_message(self.Changed())
+        self.filter_disabled = not event.value
+
+    @on(DateInput.Changed)
+    def date_input_handler(self, event: DateInput.Changed) -> None:
+        """Handle date input change."""
+        event.stop()
+        self.post_message(self.Changed())
+        date_input = event.input
+
+        if event.validation_result:
+            new_value = datetime.strptime(event.value, "%Y-%m-%d") if event.validation_result.is_valid else None
+        else:
+            new_value = None
+
+        if date_input.id == "from-date":
+            self.from_date = new_value
+        elif date_input.id == "to-date":
+            self.to_date = new_value