pyview-web 0.2.3__tar.gz → 0.2.5__tar.gz

{pyview_web-0.2.3 → pyview_web-0.2.5}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: pyview-web
-Version: 0.2.3
+Version: 0.2.5
 Summary: LiveView in Python
 License: MIT
 Keywords: web,api,LiveView
 Author: Larry Ogrodnek
 Author-email: ogrodnek@gmail.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.11,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
@@ -18,7 +18,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -31,6 +30,7 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: APScheduler (==3.9.1.post1)
+Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
 Requires-Dist: markupsafe (>=2.1.2,<3.0.0)
 Requires-Dist: psutil (>=5.9.4,<6.0.0)

{pyview_web-0.2.3 → pyview_web-0.2.5}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.2.3"
+version = "0.2.5"
 description = "LiveView in Python"
 authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
 license = "MIT"
@@ -33,7 +33,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
@@ -41,7 +40,7 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.13"
+python = ">=3.11,<3.13"
 starlette = "0.40.0"
 uvicorn = "0.30.6"
 wsproto = "1.2.0"
@@ -50,6 +49,10 @@ psutil = "^5.9.4"
 markupsafe = "^2.1.2"
 itsdangerous = "^2.1.2"
 pydantic = "^2.9.2"
+click = "^8.1.7"
+
+[tool.poetry.scripts]
+pv = "pyview.cli.main:cli"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"

pyview_web-0.2.5/pyview/async_stream_runner.py

@@ -0,0 +1,65 @@
+import asyncio
+import uuid
+import logging
+from typing import Any, AsyncGenerator, Callable, Optional
+from pyview.events.info_event import InfoEvent, InfoEventScheduler
+
+
+class AsyncStreamRunner:
+    def __init__(self, scheduler: InfoEventScheduler):
+        self._stream_tasks: dict[str, asyncio.Task] = {}
+        self._scheduler = scheduler
+
+    def start_stream(
+        self,
+        gen: AsyncGenerator[Any, None],
+        *,
+        on_yield: Callable[[Any], InfoEvent],
+        on_done: Optional[InfoEvent] = None,
+        on_error: Optional[Callable[[Exception], InfoEvent]] = None,
+        on_cancel: Optional[InfoEvent] = None,
+    ) -> str:
+        """
+        Run `gen` in the background, returning an op_id you can later use
+        to cancel.  Hooks:
+
+        - on_yield(item)  → scheduled per chunk
+        - on_done        → scheduled once at normal completion
+        - on_error(exc)  → scheduled on unexpected exception
+        - on_cancel      → scheduled if the task is cancelled
+        """
+        task_id = uuid.uuid4().hex
+
+        async def driver():
+            try:
+                async for item in gen:
+                    self._scheduler.schedule_info_once(on_yield(item))
+            except asyncio.CancelledError:
+                # user-requested cancellation
+                if on_cancel:
+                    self._scheduler.schedule_info_once(on_cancel)
+                # swallow so it doesn’t log as an “error”
+            except Exception as exc:
+                if on_error:
+                    self._scheduler.schedule_info_once(on_error(exc))
+                else:
+                    logging.exception(f"Error in stream {task_id}", exc_info=True)
+            else:
+                if on_done:
+                    self._scheduler.schedule_info_once(on_done)
+            finally:
+                self._stream_tasks.pop(task_id, None)
+
+        task = asyncio.create_task(driver())
+        self._stream_tasks[task_id] = task
+        return task_id
+
+    def cancel_stream(self, task_id: str) -> bool:
+        """
+        Cancel a running stream.  Returns True if a task was found & cancelled.
+        """
+        task = self._stream_tasks.get(task_id)
+        if not task:
+            return False
+        task.cancel()
+        return True

pyview_web-0.2.5/pyview/cli/commands/create_view.py

@@ -0,0 +1,199 @@
+import click
+from pathlib import Path
+import tomllib
+from typing import Optional
+
+
+def snake_case(name: str) -> str:
+    """Convert PascalCase or camelCase to snake_case."""
+    import re
+
+    s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def pascal_case(name: str) -> str:
+    """Convert snake_case or other formats to PascalCase."""
+    # If already in PascalCase or camelCase, convert to snake_case first
+    snake_name = snake_case(name)
+    return "".join(word.capitalize() for word in snake_name.split("_"))
+
+
+def kebab_case(name: str) -> str:
+    """Convert any case to kebab-case."""
+    return snake_case(name).replace("_", "-")
+
+
+def generate_python_file(name: str) -> str:
+    """Generate the Python LiveView file content."""
+    class_name = f"{pascal_case(name)}LiveView"
+    context_name = f"{pascal_case(name)}Context"
+
+    return f"""from pyview import LiveView, LiveViewSocket
+from dataclasses import dataclass
+from pyview.events import event, BaseEventHandler
+
+
+@dataclass
+class {context_name}:
+    pass
+
+
+class {class_name}(BaseEventHandler, LiveView[{context_name}]):
+    async def mount(self, socket: LiveViewSocket[{context_name}], session):
+        socket.context = {context_name}()
+"""
+
+
+def generate_html_file(name: str) -> str:
+    """Generate the HTML template file content."""
+    css_class = kebab_case(name)
+    return f'''<div class="{css_class}-container">
+    <h1>{pascal_case(name)}</h1>
+    
+    <div class="content">
+        <!-- Add your content here -->
+    </div>
+</div>
+'''
+
+
+def generate_css_file(name: str) -> str:
+    """Generate the CSS file content."""
+    css_class = kebab_case(name)
+    return f""".{css_class}-container {{
+    padding: 1rem;
+}}
+
+.{css_class}-container h1 {{
+    margin-bottom: 1rem;
+}}
+
+.{css_class}-container .content {{
+    /* Add your styles here */
+}}
+"""
+
+
+def generate_init_file(name: str) -> str:
+    """Generate the __init__.py file content."""
+    module_name = snake_case(name)
+    class_name = f"{pascal_case(name)}LiveView"
+
+    return f'''from .{module_name} import {class_name}
+
+__all__ = ["{class_name}"]
+'''
+
+
+def detect_package_structure(directory: Optional[Path] = None):
+    """Detect the package structure from pyproject.toml.
+
+    Args:
+        directory: Directory to look for pyproject.toml in. Defaults to current directory.
+
+    Returns:
+        tuple: (package_name, views_path)
+    """
+    if directory is None:
+        directory = Path.cwd()
+
+    pyproject_path = directory / "pyproject.toml"
+
+    if not pyproject_path.exists():
+        return None, "views"
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            config = tomllib.load(f)
+    except Exception:
+        return None, "views"
+
+    # Check for packages configuration
+    packages = config.get("tool", {}).get("poetry", {}).get("packages", [])
+    if not packages:
+        # Check for modern pyproject.toml structure
+        packages = config.get("project", {}).get("packages", [])
+
+    if not packages:
+        return None, "views"
+
+    # Find the first package entry
+    for package in packages:
+        if isinstance(package, dict) and "include" in package:
+            package_name = package["include"]
+            from_dir = package.get("from", ".")
+
+            # Construct the path where views should go
+            if from_dir == ".":
+                package_path = Path(package_name)
+            else:
+                package_path = Path(from_dir) / package_name
+
+            views_path = package_path / "views"
+            return package_name, str(views_path)
+
+    return None, "views"
+
+
+@click.command()
+@click.argument("name")
+@click.option(
+    "--path",
+    "-p",
+    default=None,
+    help="Directory to create the view in (default: auto-detect from pyproject.toml)",
+)
+@click.option("--no-css", is_flag=True, help="Skip creating CSS file")
+def create_view(name: str, path: Optional[str], no_css: bool):
+    """Create a new LiveView with boilerplate files.
+
+    Example: pv create-view Counter
+    """
+    module_name = snake_case(name)
+
+    # Always try to detect package structure for import advice
+    package_name, detected_path = detect_package_structure()
+
+    # Use detected path if no path specified, otherwise use provided path
+    if path is None:
+        path = detected_path
+
+    view_dir = Path(path) / module_name
+
+    # Check if directory already exists
+    if view_dir.exists():
+        click.secho(f"Error: Directory '{view_dir}' already exists", fg="red")
+        raise click.Abort()
+
+    view_dir.mkdir(parents=True, exist_ok=True)
+    click.secho(f"Created directory: {view_dir}", fg="green")
+
+    # Generate files
+    files_to_create = [
+        ("__init__.py", generate_init_file(name)),
+        (f"{module_name}.py", generate_python_file(name)),
+        (f"{module_name}.html", generate_html_file(name)),
+    ]
+
+    if not no_css:
+        files_to_create.append((f"{module_name}.css", generate_css_file(name)))
+
+    # Create files
+    for filename, content in files_to_create:
+        file_path = view_dir / filename
+        file_path.write_text(content)
+        click.secho(f"Created: {file_path}", fg="green")
+
+    class_name = f"{pascal_case(name)}LiveView"
+    click.echo("\nLiveView created successfully! 🎉")
+    click.echo("\nTo use this view, add it to your app:")
+
+    # import statement based on detected package structure
+    if package_name:
+        import_path = f"{package_name}.views.{module_name}"
+    else:
+        import_path = f"{path.replace('/', '.')}.{module_name}"
+
+    click.echo(f"  from {import_path} import {class_name}")
+    click.echo(f"  app.add_live_view('/{module_name}', {class_name})")

pyview_web-0.2.5/pyview/cli/main.py

@@ -0,0 +1,17 @@
+import click
+
+from pyview.cli.commands.create_view import create_view
+
+
+@click.group()
+@click.version_option(package_name="pyview-web")
+def cli():
+    """PyView CLI - Generate boilerplate for LiveView applications."""
+    pass
+
+
+cli.add_command(create_view)
+
+
+if __name__ == "__main__":
+    cli()

{pyview_web-0.2.3 → pyview_web-0.2.5}/pyview/events/BaseEventHandler.py

@@ -1,6 +1,9 @@
-from typing import Callable
+from typing import Callable, TYPE_CHECKING
 import logging
 
+if TYPE_CHECKING:
+    from pyview.live_view import InfoEvent
+
 
 def event(*event_names):
     """Decorator that marks methods as event handlers."""
@@ -12,22 +15,37 @@ def event(*event_names):
     return decorator
 
 
+def info(*info_names):
+    """Decorator that marks methods as info handlers."""
+
+    def decorator(func):
+        func._info_names = info_names
+        return func
+
+    return decorator
+
+
 class BaseEventHandler:
-    """Base class for event handlers to handle dispatching events."""
+    """Base class for event handlers to handle dispatching events and info."""
 
     _event_handlers: dict[str, Callable] = {}
+    _info_handlers: dict[str, Callable] = {}
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
 
         # Find all decorated methods and register them
         cls._event_handlers = {}
+        cls._info_handlers = {}
         for attr_name in dir(cls):
             if not attr_name.startswith("_"):
                 attr = getattr(cls, attr_name)
                 if hasattr(attr, "_event_names"):
                     for event_name in attr._event_names:
                         cls._event_handlers[event_name] = attr
+                if hasattr(attr, "_info_names"):
+                    for info_name in attr._info_names:
+                        cls._info_handlers[info_name] = attr
 
     async def handle_event(self, event: str, payload: dict, socket):
         handler = self._event_handlers.get(event)
@@ -36,3 +54,11 @@ class BaseEventHandler:
             return await handler(self, event, payload, socket)
         else:
             logging.warning(f"Unhandled event: {event} {payload}")
+
+    async def handle_info(self, info: "InfoEvent", socket):
+        handler = self._info_handlers.get(info.name)
+
+        if handler:
+            return await handler(self, info, socket)
+        else:
+            logging.warning(f"Unhandled info: {info.name} {info}")

pyview_web-0.2.5/pyview/events/__init__.py

@@ -0,0 +1,4 @@
+from .BaseEventHandler import BaseEventHandler, event, info
+from .info_event import InfoEvent
+
+__all__ = ["BaseEventHandler", "event", "info", "InfoEvent"]

pyview_web-0.2.5/pyview/events/info_event.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Any, Optional, Protocol
+
+
+@dataclass
+class InfoEvent:
+    name: str
+    payload: Any = None
+
+
+class InfoEventScheduler(Protocol):
+    def schedule_info(self, event: InfoEvent, seconds: float):
+        pass
+
+    def schedule_info_once(self, event: InfoEvent, seconds: Optional[float] = None):
+        pass

{pyview_web-0.2.3 → pyview_web-0.2.5}/pyview/live_socket.py

@@ -19,6 +19,7 @@ from pyview.uploads import UploadConstraints, UploadConfig, UploadManager
 from pyview.meta import PyViewMeta
 from pyview.template.render_diff import calc_diff
 import datetime
+from pyview.async_stream_runner import AsyncStreamRunner
 
 
 if TYPE_CHECKING:
@@ -63,6 +64,7 @@ class ConnectedLiveViewSocket(Generic[T]):
         self.pub_sub = PubSub(pub_sub_hub, topic)
         self.pending_events = []
         self.upload_manager = UploadManager()
+        self.stream_runner = AsyncStreamRunner(self)
 
     @property
     def meta(self) -> PyViewMeta:

pyview_web-0.2.3/pyview/events/__init__.py

@@ -1,4 +0,0 @@
-from .BaseEventHandler import BaseEventHandler, event
-from .info_event import InfoEvent
-
-__all__ = ["BaseEventHandler", "event", "InfoEvent"]

pyview_web-0.2.3/pyview/events/info_event.py

@@ -1,8 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass
-class InfoEvent:
-    name: str
-    payload: Any = None