pub-analyzer 0.5.6__py3-none-any.whl

pub_analyzer/widgets/report/concept.py

@@ -0,0 +1,47 @@
+"""Concepts Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.concept import DehydratedConcept
+
+
+class ConceptsTable(Static):
+    """All Concepts from a work in a table."""
+
+    DEFAULT_CSS = """
+    ConceptsTable .concepts-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, concepts_list: list[DehydratedConcept]) -> None:
+        self.concepts_list = concepts_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        concepts_table = Table(title="Concepts", expand=True, show_lines=True)
+
+        # Define Columns
+        concepts_table.add_column("", justify="center", vertical="middle")
+        concepts_table.add_column("Name", ratio=5)
+        concepts_table.add_column("Score", ratio=1)
+        concepts_table.add_column("Level", ratio=1)
+
+        for idx, concept in enumerate(self.concepts_list):
+            name = f"""[@click=app.open_link('{quote(str(concept.wikidata))}')][u]{concept.display_name}[/u][/]"""
+
+            concepts_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(f"{concept.score:.2f}"),
+                Text.from_markup(f"{concept.level:.1f}"),
+            )
+
+        yield Static(concepts_table, classes="concepts-table")

pub_analyzer/widgets/report/core.py

@@ -0,0 +1,308 @@
+"""Main Report widgets."""
+
+import datetime
+import pathlib
+from enum import Enum
+from time import time
+from typing import ClassVar
+
+import httpx
+from pydantic import TypeAdapter, ValidationError
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Container, Horizontal
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Button, LoadingIndicator, Static, TabbedContent, TabPane
+
+from pub_analyzer.internal.report import FromDate, ToDate, make_author_report, make_institution_report
+from pub_analyzer.models.author import Author
+from pub_analyzer.models.institution import Institution
+from pub_analyzer.models.report import AuthorReport, InstitutionReport
+from pub_analyzer.widgets.common import FileSystemSelector, Select
+
+from .author import AuthorReportPane
+from .export import ExportReportPane
+from .institution import InstitutionReportPane
+from .source import SourcesReportPane
+from .work import WorkReportPane
+
+
+class ReportWidget(Static):
+    """Base report widget."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding(key="ctrl+y", action="toggle_works", description="Toggle empty works"),
+    ]
+
+    show_empty_works: reactive[bool] = reactive(True)
+
+    async def action_toggle_works(self) -> None:
+        """Toggle show empty works attribute."""
+        self.show_empty_works = not self.show_empty_works
+        await self.query_one(WorkReportPane).toggle_empty_works()
+
+
+class AuthorReportWidget(ReportWidget):
+    """Author report generator view."""
+
+    def __init__(self, report: AuthorReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Create main info container and with all the widgets."""
+        with TabbedContent(id="main-container"):
+            with TabPane("Author"):
+                yield AuthorReportPane(report=self.report)
+            with TabPane("Works"):
+                yield WorkReportPane(report=self.report)
+            with TabPane("Sources"):
+                yield SourcesReportPane(report=self.report)
+            with TabPane("Export"):
+                suggest_prefix = self.report.author.display_name.lower().split()[0]
+                yield ExportReportPane(report=self.report, suggest_prefix=suggest_prefix)
+
+
+class InstitutionReportWidget(ReportWidget):
+    """Institution report generator view."""
+
+    def __init__(self, report: InstitutionReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Create main info container and with all the widgets."""
+        with TabbedContent(id="main-container"):
+            with TabPane("Institution"):
+                yield InstitutionReportPane(report=self.report)
+            with TabPane("Works"):
+                yield WorkReportPane(report=self.report)
+            with TabPane("Sources"):
+                yield SourcesReportPane(report=self.report)
+            with TabPane("Export"):
+                suggest_prefix = self.report.institution.display_name.lower().replace(" ", "-")
+                yield ExportReportPane(report=self.report, suggest_prefix=suggest_prefix)
+
+
+class CreateReportWidget(Static):
+    """Base Widget report wrapper to load data from API."""
+
+    def compose(self) -> ComposeResult:
+        """Create main info container and showing a loading animation."""
+        yield LoadingIndicator()
+        yield Container()
+
+    def on_mount(self) -> None:
+        """Hiding the empty container and calling the data in the background."""
+        self.query_one(Container).display = False
+        self.run_worker(self.mount_report(), exclusive=True)
+
+    async def make_report(self) -> Widget:
+        """Make report and create the widget."""
+        raise NotImplementedError
+
+    async def mount_report(self) -> None:
+        """Mount report."""
+        try:
+            start = time()
+            report_widget = await self.make_report()
+            elapsed = time() - start
+        except httpx.HTTPStatusError as exc:
+            self.query_one(LoadingIndicator).display = False
+            status_error = f"HTTP Exception for url: {exc.request.url}. Status code: {exc.response.status_code}"
+            self.app.notify(
+                title="Error making report!",
+                message=f"The report could not be generated due to a problem with the OpenAlex API. {status_error}",
+                severity="error",
+                timeout=20.0,
+            )
+            return None
+
+        self.app.notify(
+            title="Report created!",
+            message=f"Elapsed {elapsed:.2f}s",
+            severity="information",
+            timeout=20.0,
+        )
+
+        container = self.query_one(Container)
+        await container.mount(report_widget)
+
+        # Show results
+        self.query_one(LoadingIndicator).display = False
+        container.display = True
+
+
+class CreateAuthorReportWidget(CreateReportWidget):
+    """Widget Author report wrapper to load data from API."""
+
+    def __init__(
+        self,
+        author: Author,
+        pub_from_date: datetime.datetime | None = None,
+        pub_to_date: datetime.datetime | None = None,
+        cited_from_date: datetime.datetime | None = None,
+        cited_to_date: datetime.datetime | None = None,
+    ) -> None:
+        self.author = author
+
+        # Author publication date range
+        self.pub_from_date = pub_from_date
+        self.pub_to_date = pub_to_date
+
+        # Cited date range
+        self.cited_from_date = cited_from_date
+        self.cited_to_date = cited_to_date
+
+        super().__init__()
+
+    async def make_report(self) -> AuthorReportWidget:
+        """Make report and create the widget."""
+        pub_from_date = FromDate(self.pub_from_date) if self.pub_from_date else None
+        pub_to_date = ToDate(self.pub_to_date) if self.pub_to_date else None
+
+        cited_from_date = FromDate(self.cited_from_date) if self.cited_from_date else None
+        cited_to_date = ToDate(self.cited_to_date) if self.cited_to_date else None
+
+        report = await make_author_report(
+            author=self.author,
+            pub_from_date=pub_from_date,
+            pub_to_date=pub_to_date,
+            cited_from_date=cited_from_date,
+            cited_to_date=cited_to_date,
+        )
+        return AuthorReportWidget(report=report)
+
+
+class CreateInstitutionReportWidget(CreateReportWidget):
+    """Widget Institution report wrapper to load data from API."""
+
+    def __init__(
+        self,
+        institution: Institution,
+        pub_from_date: datetime.datetime | None = None,
+        pub_to_date: datetime.datetime | None = None,
+        cited_from_date: datetime.datetime | None = None,
+        cited_to_date: datetime.datetime | None = None,
+    ) -> None:
+        self.institution = institution
+
+        # Institution publication date range
+        self.pub_from_date = pub_from_date
+        self.pub_to_date = pub_to_date
+
+        # Cited date range
+        self.cited_from_date = cited_from_date
+        self.cited_to_date = cited_to_date
+
+        super().__init__()
+
+    async def make_report(self) -> InstitutionReportWidget:
+        """Make report and create the widget."""
+        pub_from_date = FromDate(self.pub_from_date) if self.pub_from_date else None
+        pub_to_date = ToDate(self.pub_to_date) if self.pub_to_date else None
+
+        cited_from_date = FromDate(self.cited_from_date) if self.cited_from_date else None
+        cited_to_date = ToDate(self.cited_to_date) if self.cited_to_date else None
+
+        report = await make_institution_report(
+            institution=self.institution,
+            pub_from_date=pub_from_date,
+            pub_to_date=pub_to_date,
+            cited_from_date=cited_from_date,
+            cited_to_date=cited_to_date,
+        )
+        return InstitutionReportWidget(report=report)
+
+
+class LoadReportWidget(Static):
+    """Widget report wrapper to load data from disk."""
+
+    class EntityType(Enum):
+        """Entity reports type."""
+
+        AUTHOR = AuthorReport
+        INSTITUTION = InstitutionReport
+
+    class EntityTypeSelector(Select[EntityType]):
+        """Entity type Selector."""
+
+    def __init__(self, entity_handler: EntityType = EntityType.AUTHOR) -> None:
+        self.entity_handler = entity_handler
+        super().__init__()
+
+    @on(FileSystemSelector.FileSelected)
+    def enable_button(self, event: FileSystemSelector.FileSelected) -> None:
+        """Enable button on file select."""
+        if event.file_selected:
+            self.query_one(Button).disabled = False
+        else:
+            self.query_one(Button).disabled = True
+
+    @on(Button.Pressed, "#load-report-button")
+    async def load_report(self) -> None:
+        """Load Report."""
+        from pub_analyzer.widgets.body import MainContent
+
+        file_path = self.query_one(FileSystemSelector).path_selected
+        if not file_path:
+            return
+
+        with open(file_path, encoding="utf-8") as file:
+            data = file.read()
+
+        main_content = self.app.query_one(MainContent)
+        try:
+            match self.entity_handler:
+                case self.EntityType.AUTHOR:
+                    author_report: AuthorReport = TypeAdapter(AuthorReport).validate_json(data)
+                    author_report_widget = AuthorReportWidget(report=author_report)
+                    await main_content.query("*").exclude("#page-title").remove()
+
+                    await main_content.mount(author_report_widget)
+                    main_content.update_title(title=author_report.author.display_name)
+
+                case self.EntityType.INSTITUTION:
+                    institution_report: InstitutionReport = TypeAdapter(InstitutionReport).validate_json(data)
+                    institution_report_widget = InstitutionReportWidget(report=institution_report)
+                    await main_content.query("*").exclude("#page-title").remove()
+
+                    await main_content.mount(institution_report_widget)
+                    main_content.update_title(title=institution_report.institution.display_name)
+        except ValidationError:
+            self.app.notify(
+                title="Error loading report!",
+                message="The report does not have the correct structure. This may be because it is an old version or because it is not of the specified type.",  # noqa: E501
+                severity="error",
+                timeout=10.0,
+            )
+
+    @on(Select.Changed)
+    async def on_select_entity(self, event: Select.Changed) -> None:
+        """Change entity handler."""
+        match event.value:
+            case self.EntityType.AUTHOR:
+                self.entity_handler = self.EntityType.AUTHOR
+            case self.EntityType.INSTITUTION:
+                self.entity_handler = self.EntityType.INSTITUTION
+            case _:
+                raise NotImplementedError
+
+    def compose(self) -> ComposeResult:
+        """Compose load report widget."""
+        with Horizontal(classes="filesystem-selector-container"):
+            entity_options = [(name.title(), endpoint) for name, endpoint in self.EntityType.__members__.items()]
+
+            yield FileSystemSelector(
+                path=pathlib.Path.home(),
+                only_dir=False,
+                extension=[
+                    ".json",
+                ],
+            )
+            yield self.EntityTypeSelector(options=entity_options, value=self.entity_handler, allow_blank=False)
+
+        with Horizontal(classes="button-container"):
+            yield Button("Load Report", variant="primary", disabled=True, id="load-report-button")

pub_analyzer/widgets/report/editor.py

@@ -0,0 +1,80 @@
+"""Text editor widget."""
+
+from pydantic import BaseModel
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widget import Widget
+from textual.widgets import Button, Label, Static, TextArea
+
+from pub_analyzer.widgets.common import Modal
+
+
+class TextEditor(Modal[str | None]):
+    """Text editor widget."""
+
+    def __init__(self, display_name: str, text: str) -> None:
+        self.display_name = display_name
+        self.text = text
+        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.dismiss(None)
+
+    @on(Button.Pressed, "#save")
+    def save(self) -> None:
+        """Return the edited content."""
+        self.dismiss(self.query_one(TextArea).text)
+
+    @on(Button.Pressed, "#cancel")
+    def cancel(self) -> None:
+        """Cancel action button handler."""
+        self.dismiss(None)
+
+    def compose(self) -> ComposeResult:
+        """Compose text editor."""
+        with VerticalScroll(id="dialog"):
+            yield Label(f'Editing the "{self.display_name}" field.', classes="dialog-title")
+
+            with VerticalScroll(id="text-editor-container"):
+                yield TextArea(text=self.text, theme="css", soft_wrap=True, show_line_numbers=True, tab_behavior="indent")
+
+            with Horizontal(id="actions-buttons"):
+                yield Button("Save", variant="primary", id="save")
+                yield Button("Cancel", variant="default", id="cancel")
+
+
+class EditWidget(Static):
+    """Ask for edit widget."""
+
+    def __init__(self, display_name: str, field_name: str, model: BaseModel, widget: Widget | None, widget_field: str | None) -> None:
+        self.display_name = display_name
+        self.field_name = field_name
+        self.model = model
+        self.widget = widget
+        self.widget_field = widget_field
+        super().__init__()
+
+    @on(Button.Pressed)
+    def launch_text_editor(self) -> None:
+        """Lunch Text editor."""
+
+        def save(new_text: str | None) -> None:
+            """Save changes if save button is pressed."""
+            if new_text:
+                self.app.log("Value updated.")
+                setattr(self.model, self.field_name, new_text)
+
+                if self.widget and self.widget_field:
+                    setattr(self.widget, self.widget_field, new_text)
+
+        text = getattr(self.model, self.field_name)
+        self.app.push_screen(TextEditor(self.display_name, text), callback=save)
+
+    def compose(self) -> ComposeResult:
+        """Compose widget."""
+        with Horizontal():
+            yield Button("Edit", variant="primary")

pub_analyzer/widgets/report/export.py

@@ -0,0 +1,112 @@
+"""Export report widget."""
+
+import pathlib
+from datetime import datetime
+from enum import Enum
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widgets import Button, Label
+
+from pub_analyzer.internal.render import render_report
+from pub_analyzer.models.report import AuthorReport, InstitutionReport
+from pub_analyzer.widgets.common import FileSystemSelector, Input, Select
+
+
+class ExportReportPane(VerticalScroll):
+    """Export report pane Widget."""
+
+    DEFAULT_CSS = """
+    ExportReportPane {
+        layout: vertical;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+    """
+
+    class ExportFileType(Enum):
+        """File types."""
+
+        JSON = 0
+        PDF = 1
+
+    class ExportTypeSelector(Select[ExportFileType]):
+        """Export file type selector."""
+
+    def __init__(self, report: AuthorReport | InstitutionReport, suggest_prefix: str = "") -> None:
+        self.report = report
+        self.suggest_prefix = suggest_prefix
+        super().__init__()
+
+    @on(Select.Changed)
+    async def on_select_entity(self, event: Select.Changed) -> None:
+        """Change entity endpoint."""
+        file_name_input = self.query_one(Input)
+        match event.value:
+            case self.ExportFileType.JSON:
+                file_name_input.value = f"{self.suggest_prefix}-{datetime.now().strftime('%m-%d-%Y')}.json"
+            case self.ExportFileType.PDF:
+                file_name_input.value = f"{self.suggest_prefix}-{datetime.now().strftime('%m-%d-%Y')}.pdf"
+            case _:
+                file_name_input.value = f"{self.suggest_prefix}-{datetime.now().strftime('%m-%d-%Y')}"
+
+    @on(FileSystemSelector.FileSelected)
+    def enable_button(self, event: FileSystemSelector.FileSelected) -> None:
+        """Enable button on file select."""
+        if event.file_selected:
+            self.query_one(Button).disabled = False
+        else:
+            self.query_one(Button).disabled = True
+
+    @work(exclusive=True, thread=True)
+    def _export_report(self, file_type: ExportFileType, file_path: pathlib.Path) -> None:
+        """Export report."""
+        match file_type:
+            case self.ExportFileType.JSON:
+                with open(file_path, mode="w", encoding="utf-8") as file:
+                    file.write(self.report.model_dump_json(indent=2, by_alias=True))
+            case self.ExportFileType.PDF:
+                render_report(report=self.report, file_path=file_path)
+
+        self.app.call_from_thread(
+            self.app.notify,
+            title="Report exported successfully!",
+            message=f"The report was exported correctly. You can go see it at [i]{file_path}[/]",
+            timeout=20.0,
+        )
+
+    @on(Button.Pressed, "#export-report-button")
+    async def export_report(self) -> None:
+        """Handle export report button."""
+        export_path = self.query_one(FileSystemSelector).path_selected
+        file_name = self.query_one(Input).value
+        file_type = self.query_one(self.ExportTypeSelector).value
+
+        if export_path and file_name and file_type:
+            file_path = export_path.joinpath(file_name)
+            self._export_report(file_type=file_type, file_path=file_path)
+            self.query_one(Button).disabled = True
+
+    def compose(self) -> ComposeResult:
+        """Compose content pane."""
+        suggest_file_name = f"{self.suggest_prefix}-{datetime.now().strftime('%m-%d-%Y')}.json"
+
+        with Vertical(id="export-form"):
+            with Vertical(classes="export-form-input-container"):
+                yield Label("[b]Name File:[/]", classes="export-form-label")
+                with Horizontal(classes="file-selector-container"):
+                    type_options = list(self.ExportFileType.__members__.items())
+                    selector_disabled = isinstance(self.report, InstitutionReport)
+
+                    yield Input(value=suggest_file_name, placeholder="report.json", classes="export-form-input")
+                    yield self.ExportTypeSelector(
+                        options=type_options, value=self.ExportFileType.JSON, allow_blank=False, disabled=selector_disabled
+                    )
+
+            with Vertical(classes="export-form-input-container"):
+                yield Label("[b]Export Directory:[/]", classes="export-form-label")
+                yield FileSystemSelector(path=pathlib.Path.home(), only_dir=True)
+
+            with Horizontal(classes="export-form-buttons"):
+                yield Button("Export Report", variant="primary", disabled=True, id="export-report-button")

pub_analyzer/widgets/report/grants.py

@@ -0,0 +1,85 @@
+"""Grants Widgets."""
+
+from urllib.parse import quote
+
+from rich.table import Table
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from pub_analyzer.models.work import Award, Grant
+
+
+class GrantsTable(Static):
+    """All Grants from a work in a table."""
+
+    DEFAULT_CSS = """
+    GrantsTable .grants-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, grants_list: list[Grant]) -> None:
+        self.grants_list = grants_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        grants_table = Table(title="Grants", expand=True, show_lines=True)
+
+        # Define Columns
+        grants_table.add_column("", justify="center", vertical="middle")
+        grants_table.add_column("Name", ratio=3)
+        grants_table.add_column("Award ID", ratio=2)
+
+        for idx, grant in enumerate(self.grants_list):
+            name = f"""[@click=app.open_link('{quote(str(grant.funder))}')][u]{grant.funder_display_name}[/u][/]"""
+            award_id = grant.award_id or "-"
+
+            grants_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(award_id),
+            )
+
+        yield Static(grants_table, classes="grants-table")
+
+
+class AwardsTable(Static):
+    """Grants or funding awards that support research."""
+
+    DEFAULT_CSS = """
+    GrantsTable .grants-table {
+        height: auto;
+        padding: 1 2 0 2;
+    }
+    """
+
+    def __init__(self, awards_list: list[Award]) -> None:
+        self.awards_list = awards_list
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose Table."""
+        awards_table = Table(title="Awards", expand=True, show_lines=True)
+
+        # Define Columns
+        awards_table.add_column("", justify="center", vertical="middle")
+        awards_table.add_column("Name", ratio=3)
+        awards_table.add_column("Award ID", ratio=2)
+        awards_table.add_column("DOI", ratio=2)
+
+        for idx, award in enumerate(self.awards_list):
+            name = f"""[@click=app.open_link('{quote(str(award.funder_award_id))}')][u]{award.funder_display_name}[/u][/]"""
+            award_id = award.display_name or "-"
+            doi = f"""[@click=app.open_link('{quote(str(award.doi))}')][u]{award.doi}[/u][/]""" if award.doi else "-"
+
+            awards_table.add_row(
+                str(idx),
+                Text.from_markup(name, overflow="ellipsis"),
+                Text.from_markup(award_id),
+                Text.from_markup(doi, overflow="ellipsis"),
+            )
+
+        yield Static(awards_table, classes="grants-table")

pub_analyzer/widgets/report/institution.py

@@ -0,0 +1,39 @@
+"""Institution Report Widgets."""
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, VerticalScroll
+
+from pub_analyzer.models.report import InstitutionReport
+from pub_analyzer.widgets.institution.cards import CitationMetricsCard, IdentifiersCard, RolesCard
+from pub_analyzer.widgets.institution.tables import InstitutionWorksByYearTable
+
+
+class InstitutionReportPane(VerticalScroll):
+    """Work report Pane Widget."""
+
+    DEFAULT_CSS = """
+    InstitutionReportPane {
+        layout: vertical;
+        overflow-x: hidden;
+        overflow-y: auto;
+    }
+
+    InstitutionReportPane .table-container {
+        margin: 1 0 0 0 ;
+        height: auto;
+    }
+    """
+
+    def __init__(self, report: InstitutionReport) -> None:
+        self.report = report
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose content pane."""
+        with Horizontal(classes="cards-container"):
+            yield RolesCard(institution=self.report.institution)
+            yield IdentifiersCard(institution=self.report.institution)
+            yield CitationMetricsCard(institution=self.report.institution)
+
+        with Container(classes="table-container"):
+            yield InstitutionWorksByYearTable(institution=self.report.institution)