pub-analyzer 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

pub_analyzer/widgets/common/__init__.py

@@ -7,10 +7,10 @@ from .modal import Modal
 from .selector import Select
 
 __all__ = [
-    'Card',
-    'DateInput',
-    'FileSystemSelector',
-    'Input',
-    'Modal',
-    'Select',
+    "Card",
+    "DateInput",
+    "FileSystemSelector",
+    "Input",
+    "Modal",
+    "Select",
 ]

pub_analyzer/widgets/common/filesystem.py

@@ -28,7 +28,9 @@ class PathTypeSelector(Enum):
 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:  # noqa: E501
+    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
@@ -78,7 +80,9 @@ class PathSelectorModal(Modal[Path | None]):
     }
     """
 
-    def __init__(self, path: str | Path, show_hidden_paths: bool = False, only_dir: bool = False, extension: list[str] | None = None) -> None:  # noqa: E501
+    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
@@ -90,7 +94,7 @@ class PathSelectorModal(Modal[Path | None]):
     @on(events.Key)
     def exit_modal(self, message: events.Key) -> None:
         """Exit from the modal with esc KEY."""
-        if message.key == 'escape':
+        if message.key == "escape":
             self.app.pop_screen()
 
     @on(Button.Pressed, "#done-button")
@@ -114,11 +118,10 @@ class PathSelectorModal(Modal[Path | None]):
 
     def compose(self) -> ComposeResult:
         """Compose Modal."""
-        with VerticalScroll(id='dialog'):
-            yield Label("Export Path", classes='dialog-title')
+        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
+                path=self.path, show_hidden_paths=self.show_hidden_paths, only_dir=self.only_dir, extension=self.extension
             )
 
             with Horizontal(classes="button-container"):
@@ -165,7 +168,9 @@ class FileSystemSelector(Static):
             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:  # noqa: E501
+    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
@@ -177,6 +182,7 @@ class FileSystemSelector(Static):
     @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
@@ -188,11 +194,8 @@ class FileSystemSelector(Static):
                 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
+            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:

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 valitadtion 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

pub_analyzer/widgets/common/input.py

@@ -38,7 +38,7 @@ class Input(TextualInput):
     @on(Key)
     def exit_focus(self, event: Key) -> None:
         """Unfocus from the input with esc KEY."""
-        if event.key == 'escape':
+        if event.key == "escape":
             self.screen.set_focus(None)
 
 
@@ -57,6 +57,7 @@ class DateSuggester(Suggester):
             return f"{year}-{month}-{day}"
         return None
 
+
 class DateInput(Input):
     """Input with Date validation."""
 
@@ -76,13 +77,21 @@ class DateInput(Input):
         suggester = DateSuggester()
 
         super().__init__(
-            value, placeholder, highlighter, password, suggester=suggester,
-            validators=validators, name=name, id=id, classes=classes, disabled=disabled
+            value,
+            placeholder,
+            highlighter,
+            password,
+            suggester=suggester,
+            validators=validators,
+            name=name,
+            id=id,
+            classes=classes,
+            disabled=disabled,
         )
 
         self.validators.append(
             Regex(
-                regex=r"^([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))$",
-                failure_description="Input must be formatted as `yyyy-mm-dd`"
+                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/selector.py

@@ -62,5 +62,5 @@ class Select(TextualSelect[SelectType]):
     @on(Key)
     def exit_focus(self, event: Key) -> None:
         """Unfocus from the input with esc KEY."""
-        if event.key == 'escape':
+        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/cards.py

@@ -19,12 +19,12 @@ class CitationMetricsCard(Card):
 
     def compose(self) -> ComposeResult:
         """Compose card."""
-        yield Label('[italic]Citation metrics:[/italic]', classes="card-title")
+        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}')
+        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):
@@ -36,7 +36,7 @@ class IdentifiersCard(Card):
 
     def compose(self) -> ComposeResult:
         """Compose card."""
-        yield Label('[italic]Identifiers:[/italic]', classes="card-title")
+        yield Label("[italic]Identifiers:[/italic]", classes="card-title")
 
         for platform, platform_url in self.institution.ids.model_dump().items():
             if platform_url:
@@ -55,11 +55,11 @@ class GeoCard(Card):
 
     def compose(self) -> ComposeResult:
         """Compose card."""
-        yield Label('[italic]Geo:[/italic]', classes="card-title")
+        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}')
+        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):
@@ -71,10 +71,8 @@ class RolesCard(Card):
 
     def compose(self) -> ComposeResult:
         """Compose card."""
-        yield Label('[italic]Works by roles:[/italic]', classes="card-title")
+        yield Label("[italic]Works by roles:[/italic]", classes="card-title")
 
-        with Vertical(classes='card-container'):
+        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}"""
-                )
+                yield Label(f"""[@click=app.open_link('{quote(str(role.id))}')]{role.role.value.title()}[/]: {role.works_count}""")

pub_analyzer/widgets/institution/core.py

@@ -1,82 +1,84 @@
 """Module with Widgets that allows to display the complete information of Institution using OpenAlex."""
 
-import datetime
+from typing import Any
 
 import httpx
 from textual import on
 from textual.app import ComposeResult
-from textual.containers import Container, Horizontal, Vertical, VerticalScroll
-from textual.widgets import Button, Checkbox, Label, LoadingIndicator, Static
+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 import DateInput
+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 InstitutionResumeWidget(Static):
-    """Institution info resume."""
+class _InstitutionSummaryWidget(Static):
+    """Institution info summary."""
 
-    def __init__(self, institution_result: InstitutionResult) -> None:
-        self.institution_result = institution_result
-        self.institution: Institution
+    def __init__(self, institution: Institution) -> None:
+        self.institution = institution
         super().__init__()
 
     def compose(self) -> ComposeResult:
-        """Create main info container and showing a loading animation."""
-        yield LoadingIndicator()
-        yield VerticalScroll(id="main-container")
+        """Compose institution info."""
+        is_report_not_available = self.institution.works_count < 1
 
-    def on_mount(self) -> None:
-        """Hiding the empty container and calling the data in the background."""
-        self.query_one("#main-container", VerticalScroll).display = False
-        self.run_worker(self.load_data(), exclusive=True)
+        # Compose Cards
+        with Vertical(classes="block-container"):
+            yield Label("[bold]Institution info:[/bold]", classes="block-title")
 
-    @on(Checkbox.Changed, "#filters-checkbox")
-    async def toggle_filter(self, event: Checkbox.Changed) -> None:
-        """Toggle filters."""
-        if event.checkbox.value:
-            for date_input in self.query(DateInput).results(DateInput):
-                date_input.disabled = False
-                date_input.value = ""
-        else:
-            for date_input in self.query(DateInput).results(DateInput):
-                date_input.disabled = True
-                date_input.value = ""
-                self.query_one("#make-report-button", Button).disabled = False
-
-    @on(DateInput.Changed)
-    async def enable_make_report(self, event: DateInput.Changed) -> None:
-        """Enable make report button."""
-        checkbox = self.query_one("#filters-checkbox", Checkbox)
-
-        if event.validation_result:
-            if not event.validation_result.is_valid and checkbox.value:
-                self.query_one("#make-report-button", Button).disabled = True
-            else:
-                self.query_one("#make-report-button", Button).disabled = False
+            with Horizontal(classes="cards-container"):
+                yield RolesCard(institution=self.institution)
+                yield IdentifiersCard(institution=self.institution)
+                yield CitationMetricsCard(institution=self.institution)
 
-    @on(Button.Pressed, "#make-report-button")
-    async def make_report(self) -> None:
-        """Make the institution report."""
-        checkbox = self.query_one("#filters-checkbox", Checkbox)
-        from_input = self.query_one("#from-date", DateInput)
-        to_input = self.query_one("#to-date", DateInput)
+        # Work realeted info
+        with Vertical(classes="block-container"):
+            yield Label("[bold]Work Info:[/bold]", classes="block-title")
 
-        if checkbox.value and from_input.value and to_input.value:
-            date_format = "%Y-%m-%d"
-            from_date = datetime.datetime.strptime(from_input.value, date_format)
-            to_date = datetime.datetime.strptime(to_input.value, date_format)
+            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}")
 
-            report_widget = CreateInstitutionReportWidget(institution=self.institution, from_date=from_date, to_date=to_date)
-        else:
-            report_widget = CreateInstitutionReportWidget(institution=self.institution)
+        # Count by year table section
+        with Container(classes="table-container"):
+            yield InstitutionWorksByYearTable(institution=self.institution)
 
-        await self.app.query_one("MainContent").mount(report_widget)
-        await self.app.query_one("InstitutionResumeWidget").remove()
+        # 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."""
@@ -90,67 +92,31 @@ class InstitutionResumeWidget(Static):
     async def load_data(self) -> None:
         """Query OpenAlex API and composing the widget."""
         await self._get_info()
-        container = self.query_one("#main-container", VerticalScroll)
-        is_report_not_available = self.institution.works_count < 1
+        await self.mount(_InstitutionSummaryWidget(institution=self.institution))
 
-        # Compose Cards
-        await container.mount(
-            Vertical(
-                Label('[bold]Institution info:[/bold]', classes="block-title"),
-                Horizontal(
-                    RolesCard(institution=self.institution),
-                    IdentifiersCard(institution=self.institution),
-                    CitationMetricsCard(institution=self.institution),
-                    classes="cards-container"
-                ),
-                classes="block-container"
-            )
-        )
+        self.loading = False
 
-        # Work realeted info
-        await container.mount(
-            Vertical(
-                Label('[bold]Work Info:[/bold]', classes="block-title"),
-                Horizontal(
-                    Label(f'[bold]Cited by count:[/bold] {self.institution.cited_by_count}'),
-                    Label(f'[bold]Works count:[/bold] {self.institution.works_count}'),
-                    classes="info-container"
-                ),
-                classes="block-container"
-            )
-        )
+    @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)
 
-        # Count by year table section
-        await container.mount(
-            Container(
-                InstitutionWorksByYearTable(institution=self.institution),
-                classes="table-container"
-            )
-        )
-
-        # Report Button
-        await container.mount(
-            Vertical(
-                Label('[bold]Make report:[/bold]', classes="block-title"),
-
-                # Filters
-                Horizontal(
-                    Checkbox("Filter", id="filters-checkbox"),
-                    DateInput(placeholder="From yyyy-mm-dd", disabled=True, id="from-date"),
-                    DateInput(placeholder="To yyyy-mm-dd", disabled=True, id="to-date"),
-                    classes="info-container filter-container",
-                ),
-
-                # Button
-                Vertical(
-                    Button("Make Report", variant="primary", id="make-report-button"),
-                    classes="block-container button-container"
-                ),
-                classes="block-container",
-                disabled=is_report_not_available
-            )
-        )
-
-        # Show results
-        self.query_one(LoadingIndicator).display = False
-        container.display = True
+        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

@@ -16,7 +16,7 @@ class InstitutionWorksByYearTable(Static):
 
     def compose(self) -> ComposeResult:
         """Compose Table."""
-        table = Table('Year', 'Works Count', 'Cited by Count', title="Counts by Year", expand=True)
+        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))