catime 0.2.0__tar.gz

catime-0.2.0/.github/workflows/hourly-cat.yml

@@ -0,0 +1,37 @@
+name: Hourly Cat Generator
+
+on:
+  schedule:
+    - cron: '0 * * * *'  # Every hour at :00
+  workflow_dispatch: # Allow manual trigger
+
+permissions:
+  contents: write
+  issues: write
+
+concurrency:
+  group: hourly-cat
+  cancel-in-progress: false
+
+jobs:
+  generate-cat:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: pip install nanobanana-py
+
+      - name: Generate cat and update repo
+        env:
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CAT_ISSUE_NUMBER: '1'
+          NANOBANANA_MODEL: gemini-3-pro-image-preview
+          NANOBANANA_TIMEOUT: '180'
+          NANOBANANA_FALLBACK_MODELS: gemini-3-pro-image-preview,gemini-2.5-flash-image
+        run: python scripts/generate_cat.py

catime-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish --trusted-publishing always

catime-0.2.0/.gitignore

@@ -0,0 +1,5 @@
+dist/
+.venv/
+__pycache__/
+*.egg-info/
+uv.lock

catime-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yazelin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

catime-0.2.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: catime
+Version: 0.2.0
+Summary: AI-generated hourly cat images - a new cat every hour!
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx
+Description-Content-Type: text/markdown
+
+# catime
+
+AI-generated hourly cat images. A new cat every hour!
+
+## Usage
+
+```bash
+uvx catime              # Show total cat count
+uvx catime 42           # View cat #42
+uvx catime today        # List today's cats
+uvx catime yesterday    # List yesterday's cats
+uvx catime 2026-01-30   # List all cats from a date
+uvx catime 2026-01-30T05  # View the cat from a specific hour
+uvx catime --list       # List all cats
+```

catime-0.2.0/README.md

@@ -0,0 +1,15 @@
+# catime
+
+AI-generated hourly cat images. A new cat every hour!
+
+## Usage
+
+```bash
+uvx catime              # Show total cat count
+uvx catime 42           # View cat #42
+uvx catime today        # List today's cats
+uvx catime yesterday    # List yesterday's cats
+uvx catime 2026-01-30   # List all cats from a date
+uvx catime 2026-01-30T05  # View the cat from a specific hour
+uvx catime --list       # List all cats
+```

catime-0.2.0/catlist.json

@@ -0,0 +1,15 @@
+[
+  {
+    "number": 1,
+    "timestamp": "2026-01-30 05:46 UTC",
+    "url": "https://github.com/yazelin/ccat/releases/download/cats/cat_2026-01-30_0546_UTC.png",
+    "model": "gemini-2.5-flash-image"
+  },
+  {
+    "number": 2,
+    "timestamp": "2026-01-30 05:56 UTC",
+    "url": "https://github.com/yazelin/ccat/releases/download/cats/cat_2026-01-30_0556_UTC.png",
+    "model": "gemini-3-pro-image-preview",
+    "status": "success"
+  }
+]

catime-0.2.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "catime"
+version = "0.2.0"
+description = "AI-generated hourly cat images - a new cat every hour!"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["httpx"]
+
+[project.scripts]
+catime = "catime.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/catime"]

catime-0.2.0/scripts/generate_cat.py

@@ -0,0 +1,189 @@
+"""Generate a cat image using nanobanana-py, upload as GitHub Release asset. Run by GitHub Actions hourly."""
+
+import asyncio
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+REPO = os.environ.get("GITHUB_REPOSITORY", "yazelin/catime")
+ISSUE_NUMBER = os.environ.get("CAT_ISSUE_NUMBER", "1")
+RELEASE_TAG = "cats"
+
+
+async def generate_cat_image(output_dir: str, timestamp: str) -> dict:
+    """Use nanobanana-py's ImageGenerator to generate a cat image."""
+    from nanobanana_py.image_generator import ImageGenerator
+    from nanobanana_py.types import ImageGenerationRequest
+
+    generator = ImageGenerator()
+
+    request = ImageGenerationRequest(
+        prompt=f"畫一隻可愛的貓，並在圖片中顯示現在的日期與時間: {timestamp}",
+        filename=f"cat_{timestamp.replace(' ', '_').replace(':', '')}",
+        resolution="1K",
+        file_format="png",
+        parallel=1,
+        output_count=1,
+    )
+
+    os.environ["NANOBANANA_OUTPUT_DIR"] = output_dir
+    response = await generator.generate_text_to_image(request)
+
+    if not response.success:
+        return {
+            "file_path": None,
+            "model_used": None,
+            "status": "failed",
+            "error": f"{response.message} - {response.error}",
+        }
+
+    model_info = response.model_used or "unknown"
+    if response.used_fallback:
+        model_info += f" (fallback from {response.primary_model}, reason: {response.fallback_reason})"
+
+    return {
+        "file_path": response.generated_files[0],
+        "model_used": model_info,
+        "status": "success",
+    }
+
+
+def ensure_release_exists():
+    """Create the 'cats' release if it doesn't exist."""
+    result = subprocess.run(
+        ["gh", "release", "view", RELEASE_TAG, "--repo", REPO],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        subprocess.run(
+            [
+                "gh", "release", "create", RELEASE_TAG,
+                "--repo", REPO,
+                "--title", "Cat Images",
+                "--notes", "Auto-generated cat images, one every hour.",
+            ],
+            check=True,
+        )
+
+
+def upload_image_as_release_asset(image_path: str) -> str:
+    """Upload image as a GitHub Release asset. Returns the public download URL."""
+    filename = Path(image_path).name
+
+    subprocess.run(
+        [
+            "gh", "release", "upload", RELEASE_TAG,
+            image_path,
+            "--repo", REPO,
+            "--clobber",
+        ],
+        check=True,
+    )
+
+    # Release asset URL format
+    return f"https://github.com/{REPO}/releases/download/{RELEASE_TAG}/{filename}"
+
+
+def post_issue_comment(image_url: str, number: int, timestamp: str, model_used: str):
+    """Post a comment on the issue with the cat image."""
+    body = (
+        f"## Cat #{number}\n"
+        f"**Time:** {timestamp}\n"
+        f"**Model:** `{model_used}`\n\n"
+        f"![cat-{number}]({image_url})"
+    )
+    subprocess.run(
+        ["gh", "issue", "comment", ISSUE_NUMBER, "--repo", REPO, "--body", body],
+        check=True,
+    )
+
+
+def update_catlist_and_push(entry: dict) -> int:
+    """Update catlist.json, commit and push (only JSON, no images)."""
+    catlist_path = Path("catlist.json")
+    cats = json.loads(catlist_path.read_text()) if catlist_path.exists() else []
+    cats.append(entry)
+    catlist_path.write_text(json.dumps(cats, indent=2, ensure_ascii=False) + "\n")
+
+    subprocess.run(["git", "config", "user.name", "github-actions[bot]"], check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "github-actions[bot]@users.noreply.github.com"],
+        check=True,
+    )
+    subprocess.run(["git", "add", "catlist.json"], check=True)
+
+    status = entry["status"]
+    number = entry.get("number")
+    timestamp = entry["timestamp"]
+    msg = f"Add cat #{number} - {timestamp}" if status == "success" else f"Failed cat - {timestamp}"
+    subprocess.run(["git", "commit", "-m", msg], check=True)
+
+    # Retry push with rebase in case of concurrent pushes
+    for attempt in range(3):
+        result = subprocess.run(["git", "push"], capture_output=True, text=True)
+        if result.returncode == 0:
+            break
+        print(f"Push failed (attempt {attempt + 1}), rebasing...")
+        subprocess.run(["git", "pull", "--rebase"], check=True)
+    else:
+        raise RuntimeError("Failed to push after 3 attempts")
+    return number or 0
+
+
+def main():
+    now = datetime.now(timezone.utc)
+    timestamp = now.strftime("%Y-%m-%d %H:%M UTC")
+
+    print(f"Generating cat for {timestamp}...")
+    result = asyncio.run(generate_cat_image("/tmp", timestamp))
+
+    # Read current count for numbering
+    catlist_path = Path("catlist.json")
+    cats = json.loads(catlist_path.read_text()) if catlist_path.exists() else []
+    next_number = len(cats) + 1
+
+    if result["status"] == "failed":
+        print(f"Generation failed: {result['error']}", file=sys.stderr)
+        entry = {
+            "number": None,
+            "timestamp": timestamp,
+            "url": None,
+            "model": "all failed",
+            "status": "failed",
+            "error": result["error"],
+        }
+        update_catlist_and_push(entry)
+        sys.exit(1)
+
+    image_path = result["file_path"]
+    model_used = result["model_used"]
+    print(f"Model used: {model_used}")
+
+    print("Ensuring release exists...")
+    ensure_release_exists()
+
+    print("Uploading image as release asset...")
+    image_url = upload_image_as_release_asset(image_path)
+    print(f"Image URL: {image_url}")
+
+    entry = {
+        "number": next_number,
+        "timestamp": timestamp,
+        "url": image_url,
+        "model": model_used,
+        "status": "success",
+    }
+    print("Updating catlist.json...")
+    update_catlist_and_push(entry)
+
+    print("Posting issue comment...")
+    post_issue_comment(image_url, next_number, timestamp, model_used)
+
+    print(f"Done! Cat #{next_number}")
+
+
+if __name__ == "__main__":
+    main()

catime-0.2.0/src/catime/__init__.py

@@ -0,0 +1,3 @@
+"""catime - AI-generated hourly cat images."""
+
+__version__ = "0.2.0"

catime-0.2.0/src/catime/cli.py

@@ -0,0 +1,127 @@
+"""CLI entry point for catime - view AI-generated hourly cats."""
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+import httpx
+
+CATLIST_URL = "https://raw.githubusercontent.com/{repo}/main/catlist.json"
+DEFAULT_REPO = "yazelin/catime"
+
+
+def fetch_catlist(repo: str) -> list[dict]:
+    url = CATLIST_URL.format(repo=repo)
+    resp = httpx.get(url, follow_redirects=True)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def load_local_catlist() -> list[dict]:
+    p = Path(__file__).resolve().parent.parent.parent / "catlist.json"
+    if p.exists():
+        return json.loads(p.read_text())
+    return []
+
+
+def print_cat(cat: dict, index: int | None = None):
+    """Print a single cat entry."""
+    num = cat.get("number") or index
+    status = cat.get("status", "success")
+    if status == "failed":
+        print(f"Cat #{num or '?':>4}  [FAILED]  {cat['timestamp']}  error: {cat.get('error', '?')}")
+    else:
+        print(f"Cat #{num:>4}  {cat['timestamp']}  model: {cat.get('model', '?')}")
+        print(f"  URL: {cat['url']}")
+
+
+def filter_by_query(cats: list[dict], query: str) -> list[dict]:
+    """Filter cats by time query: date, date+hour, today, yesterday."""
+    now = datetime.now(timezone.utc)
+
+    if query == "today":
+        target_date = now.strftime("%Y-%m-%d")
+        return [c for c in cats if c["timestamp"].startswith(target_date)]
+
+    if query == "yesterday":
+        target_date = (now - timedelta(days=1)).strftime("%Y-%m-%d")
+        return [c for c in cats if c["timestamp"].startswith(target_date)]
+
+    # date+hour: 2026-01-30T05 or 2026-01-30 05
+    m = re.match(r"^(\d{4}-\d{2}-\d{2})[T ](\d{1,2})$", query)
+    if m:
+        date_str, hour_str = m.group(1), m.group(2).zfill(2)
+        prefix = f"{date_str} {hour_str}:"
+        return [c for c in cats if c["timestamp"].startswith(prefix)]
+
+    # date only: 2026-01-30
+    if re.match(r"^\d{4}-\d{2}-\d{2}$", query):
+        return [c for c in cats if c["timestamp"].startswith(query)]
+
+    return []
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="catime",
+        description="View AI-generated hourly cat images",
+    )
+    parser.add_argument(
+        "query", nargs="?",
+        help="Cat number (e.g. 42), date (2026-01-30), date+hour (2026-01-30T05), 'today', or 'yesterday'.",
+    )
+    parser.add_argument("--repo", default=DEFAULT_REPO, help="GitHub repo owner/name")
+    parser.add_argument("--local", action="store_true", help="Use local catlist.json")
+    parser.add_argument("--list", action="store_true", help="List all cats")
+    args = parser.parse_args()
+
+    try:
+        cats = load_local_catlist() if args.local else fetch_catlist(args.repo)
+    except Exception as e:
+        print(f"Error loading cat list: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not cats:
+        print("No cats yet! Check back in an hour.")
+        return
+
+    if args.list:
+        for i, cat in enumerate(cats, 1):
+            print_cat(cat, i)
+        return
+
+    if args.query is None:
+        print(f"Total cats: {len(cats)}")
+        print(f"Latest: #{len(cats):04d}  {cats[-1]['timestamp']}")
+        print()
+        print("Usage:")
+        print("  catime 42              View cat #42")
+        print("  catime today           List today's cats")
+        print("  catime yesterday       List yesterday's cats")
+        print("  catime 2026-01-30      List all cats from a date")
+        print("  catime 2026-01-30T05   View the cat from a specific hour")
+        print("  catime --list          List all cats")
+        return
+
+    # Try as number first
+    if args.query.isdigit():
+        idx = int(args.query) - 1
+        if idx < 0 or idx >= len(cats):
+            print(f"Cat #{args.query} not found. Available: 1-{len(cats)}", file=sys.stderr)
+            sys.exit(1)
+        print_cat(cats[idx], int(args.query))
+        return
+
+    # Try as time query
+    matched = filter_by_query(cats, args.query)
+    if not matched:
+        print(f"No cats found for '{args.query}'.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Found {len(matched)} cat(s) for '{args.query}':\n")
+    for cat in matched:
+        print_cat(cat)
+        print()