kiosque 0.1.0__py3-none-any.whl

kiosque/__init__.py

@@ -0,0 +1,159 @@
+# from .aviationweek import AviationWeek
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import click
+
+from .core.config import config_dict, configuration_file  # noqa: F401
+from .core.website import Website
+from .tui.tui import main as tui_main
+
+
+def list_websites() -> None:
+    """List all supported websites with their authentication status."""
+    website_dir = Path(__file__).parent / "website"
+    websites_info = []
+
+    for module_file in sorted(website_dir.glob("*.py")):
+        if module_file.stem.startswith("_"):
+            continue
+
+        content = module_file.read_text()
+
+        # Extract base_url
+        base_url = None
+        for line in content.split("\n"):
+            if "base_url = " in line and "http" in line:
+                # Extract URL from string
+                base_url = (
+                    line.split('"')[1] if '"' in line else line.split("'")[1]
+                )
+                break
+
+        # Check if login_url is defined (indicates auth required)
+        needs_auth = "login_url = " in content
+
+        # Extract class name for display
+        class_name = None
+        for line in content.split("\n"):
+            if line.startswith("class ") and "(Website)" in line:
+                class_name = line.split("class ")[1].split("(")[0]
+                break
+
+        if base_url and class_name:
+            websites_info.append(
+                {
+                    "name": class_name,
+                    "url": base_url,
+                    "auth": "Yes" if needs_auth else "No",
+                }
+            )
+
+    # Print header
+    click.echo("\nSupported Websites:")
+    click.echo("=" * 80)
+    click.echo(f"{'Website':<30} {'Authentication':<15} {'URL':<35}")
+    click.echo("-" * 80)
+
+    # Print websites
+    for info in websites_info:
+        click.echo(f"{info['name']:<30} {info['auth']:<15} {info['url']:<35}")
+
+    click.echo("=" * 80)
+    click.echo(f"\nTotal: {len(websites_info)} websites supported\n")
+
+
+@click.command(
+    help="Read newspaper articles in textual format. Launches TUI by default."
+)
+@click.argument("url_or_alias", required=False)
+@click.argument("output", type=click.File("w"), required=False, default=None)
+@click.option("-v", "--verbose", count=True, help="Verbosity level")
+@click.option(
+    "--list-websites",
+    "show_list",
+    is_flag=True,
+    help="List all supported websites",
+)
+def main(
+    url_or_alias: str | None,
+    output: Path | None,
+    verbose: int,
+    show_list: bool,
+) -> None:
+    # Handle --list-websites flag
+    if show_list:
+        list_websites()
+        return
+
+    # Launch TUI by default when no arguments provided
+    if url_or_alias is None:
+        tui_main()
+        return
+
+    # Configure logging
+    logging.basicConfig(
+        level=logging.WARNING,
+        format="%(levelname)s: %(message)s",
+    )
+    logger = logging.getLogger()
+
+    if verbose == 1:
+        logger.setLevel(logging.INFO)
+    elif verbose > 1:
+        logger.setLevel(logging.DEBUG)
+
+    if isinstance(output, str):
+        output = Path(output)
+
+    library: dict[str, type[Website]] = dict()
+
+    for key, value in config_dict.items():
+        if not key.startswith("http"):
+            continue
+
+        logging.debug(f"Parsing configuration for {key}")
+        if not key.endswith("/"):
+            key += "/"
+
+        library[key] = website = Website.instance(key).__class__
+
+        if "alias" in value:
+            for alias in value["alias"].split(","):
+                logging.debug(f"Setting alias '{alias}' for {website}")
+                website.alias.append(alias)
+
+            for alias in website.alias:
+                library[alias] = website
+
+    logging.debug(f"List of aliases: {library}")
+
+    try:
+        if url_or_alias == "tui":
+            tui_main()
+        elif url_or_alias in library:
+            library[url_or_alias]().save_latest_issue()
+        elif output is None or isinstance(output, Path):
+            instance = Website.instance(url_or_alias)
+            instance.write_text(url_or_alias, output)
+        else:
+            # If it should be written to -
+            instance = Website.instance(url_or_alias)
+            content = instance.full_text(url_or_alias)
+            output.write(content)
+    except ValueError as e:
+        logging.error(str(e))
+        raise click.ClickException(str(e))
+    except NotImplementedError as e:
+        logging.error(str(e))
+        raise click.ClickException(str(e))
+    except Exception as e:
+        logging.error(f"An unexpected error occurred: {e}")
+        if verbose > 0:
+            raise
+        else:
+            raise click.ClickException(
+                f"An error occurred. Use -v for more details: {e}"
+            )

kiosque/__main__.py

@@ -0,0 +1,17 @@
+import os
+import sys
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == "":
+    # __file__ is kiosque-*.whl/kiosque/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+from kiosque import main
+
+if __name__ == "__main__":
+    main()

kiosque/api/github.py

@@ -0,0 +1,236 @@
+from datetime import datetime
+from typing import Any
+
+import httpx
+from pydantic import BaseModel, Field, HttpUrl, field_validator
+
+from ..core.config import config_dict
+
+
+class GitHubRepo(BaseModel):
+    """Model representing a GitHub repository."""
+
+    id: int
+    name: str
+    full_name: str
+    html_url: HttpUrl
+    description: str | None = None
+    language: str | None = None
+    stargazers_count: int = 0
+    topics: list[str] = Field(default_factory=list)
+    created_at: datetime
+    updated_at: datetime
+    pushed_at: datetime
+    homepage: HttpUrl | None = None
+    owner: dict[str, Any]  # Contains login, avatar_url, etc.
+
+    # Additional fields for starred repos
+    starred_at: datetime | None = None
+
+    @field_validator("homepage", mode="before")
+    @classmethod
+    def validate_homepage(cls, v: str | None) -> str | None:
+        """Validate homepage URL, converting empty strings to None."""
+        if v == "" or v is None:
+            return None
+        return v
+
+
+class GitHubAPI:
+    """API client for interacting with GitHub.
+
+    Go to https://github.com/settings/tokens
+    Create a classic token with 'public_repo' or 'repo' scope
+    """
+
+    def __init__(self) -> None:
+        github_config = config_dict.get("github", None)
+        assert github_config is not None, "GitHub configuration not found."
+
+        self.token = github_config.get("token")
+        self.headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+        self.client = httpx.Client(headers=self.headers, timeout=30.0)
+        self.async_client = httpx.AsyncClient(
+            headers=self.headers, timeout=30.0
+        )
+
+    async def get_user_async(self) -> dict[str, Any]:
+        """Get the authenticated user's information."""
+        response = await self.async_client.get("https://api.github.com/user")
+        response.raise_for_status()
+        return response.json()
+
+    async def get_starred_repos_async(
+        self, page: int = 1, per_page: int = 100
+    ) -> list[GitHubRepo]:
+        """Get starred repositories for the authenticated user.
+
+        Args:
+            page: Page number (1-indexed)
+            per_page: Number of results per page (max 100)
+
+        Returns:
+            List of GitHubRepo objects
+        """
+        # Use the star timestamp header to get when repos were starred
+        headers = {
+            **self.headers,
+            "Accept": "application/vnd.github.star+json",
+        }
+        response = await self.async_client.get(
+            "https://api.github.com/user/starred",
+            params={"page": page, "per_page": per_page},
+            headers=headers,
+        )
+        response.raise_for_status()
+
+        repos = []
+        for item in response.json():
+            repo_data = item["repo"]
+            repo_data["starred_at"] = item["starred_at"]
+            repos.append(GitHubRepo(**repo_data))
+
+        return repos
+
+    async def get_all_starred_repos_async(self) -> list[GitHubRepo]:
+        """Get all starred repositories (handles pagination automatically)."""
+        all_repos = []
+        page = 1
+
+        while True:
+            repos = await self.get_starred_repos_async(page=page, per_page=100)
+            if not repos:
+                break
+            all_repos.extend(repos)
+            if len(repos) < 100:  # Last page
+                break
+            page += 1
+
+        return all_repos
+
+    async def get_readme_async(self, owner: str, repo: str) -> str | None:
+        """Get the README content for a repository.
+
+        Args:
+            owner: Repository owner (username or organization)
+            repo: Repository name
+
+        Returns:
+            README content in markdown format, or None if not found
+        """
+        try:
+            response = await self.async_client.get(
+                f"https://api.github.com/repos/{owner}/{repo}/readme",
+                headers={
+                    **self.headers,
+                    "Accept": "application/vnd.github.raw+json",
+                },
+            )
+            response.raise_for_status()
+            return response.text
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return None  # No README found
+            raise
+
+    async def get_languages_async(
+        self, owner: str, repo: str
+    ) -> dict[str, int]:
+        """Get languages used in a repository.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dictionary mapping language names to bytes of code
+        """
+        response = await self.async_client.get(
+            f"https://api.github.com/repos/{owner}/{repo}/languages"
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def unstar_repo_async(self, owner: str, repo: str) -> None:
+        """Unstar a repository.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+        """
+        response = await self.async_client.delete(
+            f"https://api.github.com/user/starred/{owner}/{repo}"
+        )
+        response.raise_for_status()
+
+    async def star_repo_async(self, owner: str, repo: str) -> None:
+        """Star a repository.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+        """
+        response = await self.async_client.put(
+            f"https://api.github.com/user/starred/{owner}/{repo}"
+        )
+        response.raise_for_status()
+
+    async def is_starred_async(self, owner: str, repo: str) -> bool:
+        """Check if a repository is starred.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            True if starred, False otherwise
+        """
+        response = await self.async_client.get(
+            f"https://api.github.com/user/starred/{owner}/{repo}"
+        )
+        return response.status_code == 204
+
+    async def async_retrieve(self, offset: int = 0) -> dict[str, Any]:
+        """Legacy method for compatibility with TUI - returns formatted data.
+
+        Args:
+            offset: Offset for pagination (not used, GitHub API uses pages)
+
+        Returns:
+            Dict with 'list' (dict of repos by ID) and 'count'
+        """
+        repos = await self.get_all_starred_repos_async()
+
+        # Convert to format expected by TUI
+        items_dict = {str(repo.id): repo for repo in repos}
+        return {"list": items_dict, "count": len(repos)}
+
+    async def async_action(
+        self, action: str, repo_id: int, owner: str, repo: str
+    ) -> None:
+        """Perform an action on a repository.
+
+        Args:
+            action: Action to perform ('unstar', etc.)
+            repo_id: Repository ID (for compatibility)
+            owner: Repository owner
+            repo: Repository name
+        """
+        if action == "unstar":
+            await self.unstar_repo_async(owner, repo)
+        else:
+            raise ValueError(f"Unknown action: {action}")
+
+    def close(self) -> None:
+        """Close HTTP clients."""
+        self.client.close()
+        self.async_client.close()
+
+    async def aclose(self) -> None:
+        """Async close HTTP clients."""
+        await self.async_client.aclose()
+        self.client.close()

kiosque/api/pocket.py

@@ -0,0 +1,133 @@
+from typing import Iterator, Literal, TypedDict
+
+import httpx
+
+from ..core.config import config_dict
+
+
+class UnknownJSON(TypedDict): ...
+
+
+class PocketRetrieveEntry(TypedDict):
+    item_id: str
+    resolved_id: str  # useful for duplicates
+    given_url: str
+    resolved_url: str
+    given_title: str
+    resolved_title: str
+    favorite: Literal[0, 1]
+    status: Literal[0, 1, 2]
+    excerpt: str  # articles only
+    is_article: Literal[0, 1]
+    has_image: Literal[0, 1, 2]
+    has_video: Literal[0, 1, 2]
+    word_count: str
+    tags: UnknownJSON
+    authors: UnknownJSON
+    images: UnknownJSON
+    videos: UnknownJSON
+    time_added: str
+
+
+class PocketRetrieveResponse(TypedDict):
+    maxActions: int
+    status: Literal[0, 1]
+    list: dict[str, PocketRetrieveEntry]
+
+
+class PocketAPI:
+    json: PocketRetrieveResponse
+
+    def __init__(self):
+        pocket_config = config_dict.get("getpocket.com", None)
+        assert pocket_config is not None
+
+        self.consumer_key = pocket_config.get("consumer_key")
+        self.access_token = pocket_config.get("access_token")
+        self.client = httpx.Client()
+        self.async_client = httpx.AsyncClient()
+
+    def __len__(self):
+        return len(self.json["list"])
+
+    def __getitem__(self, select):
+        for i, elt in enumerate(self.json["list"].values()):
+            if i == select:
+                return elt
+
+    def __iter__(self) -> Iterator[PocketRetrieveEntry]:
+        yield from self.json["list"].values()
+
+    def retrieve(self, offset=30) -> PocketRetrieveResponse:
+        # https://getpocket.com/developer/docs/v3/retrieve
+        r = self.client.post(
+            "https://getpocket.com/v3/get",
+            json={
+                "consumer_key": self.consumer_key,
+                "access_token": self.access_token,
+                "count": 30,
+                "offset": offset,
+                "total": 1,
+                "sort": "newest",
+            },
+            headers={
+                "Content-Type": "application/json",
+                "X-Accept": "application/json",
+            },
+        )
+        r.raise_for_status()
+        self.json = r.json()
+        return self.json
+
+    async def async_retrieve(self, offset=0) -> PocketRetrieveResponse:
+        r = await self.async_client.post(
+            "https://getpocket.com/v3/get",
+            json={
+                "consumer_key": self.consumer_key,
+                "access_token": self.access_token,
+                "count": 30,
+                "offset": offset,
+                "total": 1,
+                "sort": "newest",
+                "state": "unread",
+            },
+            headers={
+                "Content-Type": "application/json",
+                "X-Accept": "application/json",
+            },
+        )
+        r.raise_for_status()
+        self.json = r.json()
+        return self.json
+
+    def action(self, action: str, item_id: str):
+        r = self.client.post(
+            "https://getpocket.com/v3/send",
+            json={
+                "consumer_key": self.consumer_key,
+                "access_token": self.access_token,
+                "actions": [{"action": action, "item_id": item_id}],
+            },
+            headers={
+                "Content-Type": "application/json",
+                "X-Accept": "application/json",
+            },
+        )
+        r.raise_for_status()
+        return r.json()
+
+    async def async_action(self, action: str, item_id: str):
+        r = await self.async_client.post(
+            "https://getpocket.com/v3/send",
+            json={
+                "consumer_key": self.consumer_key,
+                "access_token": self.access_token,
+                "actions": [{"action": action, "item_id": item_id}],
+            },
+            headers={
+                "Content-Type": "application/json",
+                "X-Accept": "application/json",
+            },
+        )
+        r.raise_for_status()
+        return r.json()