cosmol-viewer 0.1.2.dev5__cp37-abi3-macosx_10_12_x86_64.whl → 0.1.3.dev2__cp37-abi3-macosx_10_12_x86_64.whl

cosmol_viewer/__init__.pyi

@@ -0,0 +1,315 @@
+from typing import Optional, Union, List 
+
+def parse_sdf(
+    sdf: str,
+    keep_h: bool = True,
+    multimodel: bool = True,
+    onemol: bool = False
+) -> "MoleculeData":
+    """
+    Parse an SDF file or string into molecule data.
+
+    # Args
+      - sdf: Path to an SDF file or a string containing SDF content.
+      - keep_h: Whether to keep explicit hydrogen atoms (default: True).
+      - multimodel: Whether to allow multiple models in one file (default: True).
+      - onemol: Whether to merge multiple models into one molecule (default: False).
+
+    # Returns
+      - MoleculeData: Parsed molecule data object.
+
+    # Example
+    ```python
+    from cosmol_viewer import parse_sdf
+    mol = parse_sdf("molecule.sdf")
+    ```
+    """
+    ...
+
+
+class Scene:
+    """
+    A 3D scene container for visualizing molecular or geometric shapes.
+
+    This class allows adding, updating, and removing shapes in a 3D scene,
+    as well as modifying scene-level properties like scale and background color.
+
+    Supported shape types:
+      - PySphere
+      - PyStick
+      - PyMolecules
+
+    Shapes can be optionally identified with a string `id`,
+    which allows updates and deletion.
+    """
+
+    def __init__(self) -> None:
+        """
+        Creates a new empty scene.
+
+        # Example
+        ```python
+        scene = Scene()
+        ```
+        """
+        ...
+
+    def add_shape(self, shape: Union["Sphere", "Stick", "Molecules"], id: Optional[str] = None) -> None:
+        """
+        Add a shape to the scene.
+
+        # Args
+          - shape: A shape instance (PySphere, PyStick, or PyMolecules).
+          - id: Optional string ID to associate with the shape.
+
+        If the `id` is provided and a shape with the same ID exists,
+        the new shape will replace it.
+
+        # Example
+        ```python
+        scene.add_shape(sphere)
+        scene.add_shape(stick, id="bond1")
+        ```
+        """
+        ...
+
+    def update_shape(self, id: str, shape: Union["Sphere", "Stick", "Molecules"]) -> None:
+        """
+        Update an existing shape in the scene by its ID.
+
+        # Args
+          - id: ID of the shape to update.
+          - shape: New shape object to replace the existing one.
+
+        # Example
+        ```python
+        scene.update_shape("atom1", updated_sphere)
+        ```
+        """
+        ...
+
+    def delete_shape(self, id: str) -> None:
+        """
+        Remove a shape from the scene by its ID.
+
+        # Args
+          - id: ID of the shape to remove.
+
+        # Example
+        ```python
+        scene.delete_shape("bond1")
+        ```
+        """
+        ...
+
+    def scale(self, scale: float) -> None:
+        """
+        Set the global scale factor of the scene.
+
+        This affects the visual size of all shapes uniformly.
+
+        # Args
+          - scale: A positive float scaling factor.
+
+        # Example
+        ```python
+        scene.scale(1.5)
+        ```
+        """
+        ...
+
+    def set_background_color(self, background_color: List[float]) -> None:
+        """
+        Set the background color of the scene.
+
+        # Args
+          - background_color: An RGB array of 3 float values between 0.0 and 1.0.
+
+        # Example
+        ```python
+        scene.set_background_color([1.0, 1.0, 1.0])  # white background
+        ```
+        """
+        ...
+
+class Viewer:
+    """
+    A viewer that renders 3D scenes in different runtime environments
+    (e.g., Jupyter, Colab, or native GUI).
+
+    The `Viewer` automatically selects a backend:
+      - Jupyter/Colab → WebAssembly canvas (inline display)
+      - Python script/terminal → native GUI window (if supported)
+
+    Use `Viewer.render(scene)` to create and display a viewer instance.
+    """
+
+    @staticmethod
+    def get_environment() -> str:
+        """
+        Get the current runtime environment.
+
+        # Returns
+          - str: One of "Jupyter", "Colab", "PlainScript", or "IPythonTerminal".
+
+        # Example
+        ```python
+        env = Viewer.get_environment()
+        print(env)  # e.g., "Jupyter"
+        ```
+        """
+        ...
+
+    @staticmethod
+    def render(scene: "Scene", width: float = 800.0, height: float = 600.0) -> "Viewer":
+        """
+        Render a 3D scene.
+
+        # Args
+          - scene: The scene to render.
+          - width: The viewport width in pixels (default: 800).
+          - height: The viewport height in pixels (default: 600).
+
+        # Returns
+          - Viewer: The created viewer instance.
+
+        # Example
+        ```python
+        from cosmol_viewer import Viewer, Scene, Sphere
+        scene = Scene()
+        scene.add_shape(Sphere([0, 0, 0], 1.0))
+        viewer = Viewer.render(scene)
+        ```
+        """
+        ...
+
+    @staticmethod
+    def play(
+        frames: List["Scene"],
+        interval: float,
+        loops: int,
+        width: float = 800.0,
+        height: float = 600.0
+    ) -> "Viewer":
+        """
+        Play an animation of multiple frames.
+
+        # Args
+          - frames: List of Scene objects as animation frames.
+          - interval: Frame interval in seconds.
+          - loops: Number of loops to repeat (-1 for infinite).
+          - width: The viewport width in pixels.
+          - height: The viewport height in pixels.
+
+        # Returns
+          - Viewer: The created viewer instance.
+
+        # Example
+        ```python
+        viewer = Viewer.play([scene1, scene2], interval=0.5, loops=3)
+        ```
+        """
+        ...
+
+    def update(self, scene: "Scene") -> None:
+        """
+        Update the viewer with a new scene.
+
+        Works for both Web-based rendering (Jupyter/Colab) and native GUI windows.
+
+        ⚠️ Note (Jupyter/Colab): Animation updates may be limited by
+        notebook rendering capacity.
+
+        # Args
+          - scene: The updated scene.
+
+        # Example
+        ```python
+        scene.add_shape(Sphere([1, 1, 1], 0.5))
+        viewer.update(scene)
+        ```
+        """
+        ...
+
+    def save_image(self, path: str) -> None:
+        """
+        Save the current image to a file.
+
+        # Args
+          - path: File path for the saved image.
+
+        # Example
+        ```python
+        viewer.save_image("output.png")
+        ```
+        """
+        ...
+
+class Sphere:
+    """
+    A sphere shape in the scene.
+
+    # Args
+      - center: [x, y, z] coordinates of the sphere center.
+      - radius: Radius of the sphere.
+
+    # Example
+    ```python
+    sphere = Sphere([0, 0, 0], 1.0).color([1, 0, 0])
+    ```
+    """
+
+    def __init__(self, center: List[float], radius: float) -> None: ...
+    def set_center(self, center: List[float]) -> "Sphere": ...
+    def set_radius(self, radius: float) -> "Sphere": ...
+    def color(self, color: List[float]) -> "Sphere": ...
+    def color_rgba(self, color: List[float]) -> "Sphere": ...
+    def opacity(self, opacity: float) -> "Sphere": ...
+
+
+class Stick:
+    """
+    A cylindrical stick (or capsule) connecting two points.
+
+    # Args
+      - start: Starting point [x, y, z].
+      - end: Ending point [x, y, z].
+      - thickness: Stick radius.
+
+    # Example
+    ```python
+    stick = Stick([0,0,0], [1,1,1], 0.1).opacity(0.5)
+    ```
+    """
+
+    def __init__(self, start: List[float], end: List[float], thickness: float) -> None: ...
+    def color(self, color: List[float]) -> "Stick": ...
+    def color_rgba(self, color: List[float]) -> "Stick": ...
+    def opacity(self, opacity: float) -> "Stick": ...
+    def set_thickness(self, thickness: float) -> "Stick": ...
+    def set_start(self, start: List[float]) -> "Stick": ...
+    def set_end(self, end: List[float]) -> "Stick": ...
+
+
+class Molecules:
+    """
+    A molecular shape object parsed from SDF data.
+
+    # Example
+    ```python
+    mol = parse_sdf("molecule.sdf")
+    molecules = Molecules(mol).centered().color([0,1,0])
+    ```
+    """
+
+    def __init__(self, molecule_data: "MoleculeData") -> None: ...
+    def centered(self) -> "Molecules": ...
+    def color(self, color: List[float]) -> "Molecules": ...
+    def color_rgba(self, color: List[float]) -> "Molecules": ...
+    def opacity(self, opacity: float) -> "Molecules": ...
+
+class MoleculeData:
+    """
+    Internal representation of molecule data returned by `parse_sdf`.
+    """
+    ...

cosmol_viewer-0.1.3.dev2.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: cosmol-viewer
+Version: 0.1.3.dev2
+Summary: Molecular visualization tools
+Author-email: 95028 <wjt@cosmol.org>
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/COSMol-repl/COSMol-viewer
+
+# COSMol-viewer
+
+<div align="center">
+  <a href="https://crates.io/crates/cosmol_viewer">
+    <img src="https://img.shields.io/crates/v/cosmol_viewer.svg" alt="crates.io Latest Release"/>
+  </a>
+  <a href="https://pypi.org/project/cosmol_viewer/">
+    <img src="https://img.shields.io/pypi/v/cosmol_viewer.svg" alt="PyPi Latest Release"/>
+  </a>
+  <a href="https://cosmol-repl.github.io/COSMol-viewer">
+    <img src="https://img.shields.io/badge/docs-latest-blue.svg" alt="Documentation Status"/>
+  </a>
+</div>
+
+**COSMol-viewer** is a high-performance molecular visualization library, written in **Rust** and powered by **WebGPU**, designed for seamless integration into **Python** workflows.  
+
+- ⚡ **High-speed rendering** — GPU-accelerated performance at native speed  
+- 🧬 **Flexible input** — Load structures from `.sdf`, `.pdb`, or dynamically generated coordinates  
+- 📓 **Notebook-ready** — Fully compatible with Jupyter and Google Colab, ideal for teaching, research, and interactive demos  
+- 🔁 **Dynamic visualization** — Update molecular structures on-the-fly or play smooth preloaded animations  
+- 🎨 **Customizable** — Fine-grained control of rendering styles, camera, and scene parameters  
+
+---
+
+## Installation
+
+```sh
+pip install cosmol-viewer
+```
+
+---
+
+## Quick Start
+
+```python
+from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
+
+# === Step 1: Load and render a molecule ===
+with open("molecule.sdf", "r") as f:
+    sdf = f.read()
+    mol = Molecules(parse_sdf(sdf)).centered()
+
+scene = Scene()
+scene.scale(0.1)
+scene.add_shape(mol, "mol")
+
+viewer = Viewer.render(scene, width=600, height=400)  # Launch viewer
+
+print("Press Any Key to exit...", end='', flush=True)
+_ = input()  # Keep the viewer open until you decide to close
+```
+
+---
+
+## Animation Modes
+
+COSMol-viewer supports **two complementary animation workflows**, depending on whether you prefer **real-time updates** or **preloaded playback**.
+
+### 1. Real-Time Updates (Frame-by-Frame Streaming)
+
+Update the molecule directly inside an existing scene:
+
+```python
+import time
+from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
+
+scene = Scene()
+scene.scale(0.1)
+
+# Initial load
+with open("frames/frame_1.sdf", "r") as f:
+    sdf = f.read()
+    mol = Molecules(parse_sdf(sdf)).centered()
+scene.add_shape(mol, "mol")
+
+viewer = Viewer.render(scene, width=600, height=400)
+
+# Update in real time
+for i in range(2, 10):
+    with open(f"frames/frame_{i}.sdf", "r") as f:
+        sdf = f.read()
+        updated_mol = Molecules(parse_sdf(sdf)).centered()
+
+    scene.update_shape("mol", updated_mol)
+    viewer.update(scene)
+
+    time.sleep(0.033)  # ~30 FPS
+
+print("Press Any Key to exit...", end='', flush=True)
+_ = input()
+```
+
+**Use cases:**  
+- Visualizing the *progress* of a simulation step-by-step  
+- Interactive experiments or streaming scenarios where frames are not known in advance  
+
+**Trade-offs:**  
+- ✅ Low memory usage — no need to preload frames  
+- ⚠️ Playback smoothness depends on computation / I/O speed → may stutter if frame generation is slow  
+
+---
+
+### 2. Preloaded Playback (One-Shot Animation) (Start from 0.1.3)
+
+Load all frames into memory first, then play them back smoothly:
+
+```python
+from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
+
+frames = []
+interval = 0.033  # ~30 FPS
+
+# Preload all frames
+for i in range(1, 10):
+    with open(f"frames/frame_{i}.sdf", "r") as f:
+        sdf = f.read()
+        mol = Molecules(parse_sdf(sdf)).centered()
+
+    scene = Scene()
+    scene.scale(0.1)
+    scene.add_shape(mol, "mol")
+    frames.append(scene)
+
+# Playback once
+Viewer.play(frames, interval=interval, loops=1, width=600, height=400)
+
+print("Press Any Key to exit...", end='', flush=True)
+_ = input()
+```
+
+**Use cases:**  
+- Smooth, stable playback for presentations or teaching  
+- Demonstrating precomputed trajectories (e.g., molecular dynamics snapshots)  
+
+**Trade-offs:**  
+- ✅ Very smooth playback, independent of computation speed  
+- ⚠️ Requires preloading all frames → higher memory usage  
+- ⚠️ Longer initial load time for large trajectories  
+
+---
+
+## Choosing the Right Mode
+
+- ✅ Use **real-time updates** if your frames are generated on-the-fly or memory is limited  
+- ✅ Use **preloaded playback** if you want guaranteed smooth animations and can preload your trajectory  
+
+---
+
+## Exiting the Viewer
+
+> **Important:** The viewer is bound to the Python process.  
+> When your script finishes, the rendering window will close automatically.
+
+To keep the visualization alive until you are ready to exit, always add:
+
+```python
+print("Press Any Key to exit...", end='', flush=True)
+_ = input()
+```
+
+This ensures:  
+- The window stays open for inspection  
+- The user decides when to end visualization  
+- Prevents premature termination at the end of the script  
+
+---
+
+## Documentation
+
+For API reference and advanced usage, please see the [latest documentation](https://cosmol-repl.github.io/COSMol-viewer).  
+

cosmol_viewer-0.1.3.dev2.dist-info/RECORD

@@ -0,0 +1,7 @@
+cosmol_viewer-0.1.3.dev2.dist-info/METADATA,sha256=BpvjCIRGgH-ituEwGJsGtC4x6NlZp2KVTMSaKjaDbmc,5289
+cosmol_viewer-0.1.3.dev2.dist-info/WHEEL,sha256=EXWYGIlQOGI1SAWXpNs-tKqcTH553LQS8liEUK4J-U8,104
+cosmol_viewer/__init__.py,sha256=K33zoYpHqUVvpFdMVxmCtw4uKj9ZXrGuQD4D4DuUmjk,135
+cosmol_viewer/__init__.pyi,sha256=JzeDsMSjCE2ErFohX6fzrWVPUYVsEPksIVqc0b6J6DU,8256
+cosmol_viewer/cosmol_viewer.abi3.so,sha256=0Q2ZXaeZOz-mm_FE8m-pG-qJ96hNMl1gnUeG3NCbc2g,14423592
+cosmol_viewer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cosmol_viewer-0.1.3.dev2.dist-info/RECORD,,

{cosmol_viewer-0.1.2.dev5.dist-info → cosmol_viewer-0.1.3.dev2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.1)
+Generator: maturin (1.9.4)
 Root-Is-Purelib: false
 Tag: cp37-abi3-macosx_10_12_x86_64

cosmol_viewer-0.1.2.dev5.dist-info/METADATA

@@ -1,70 +0,0 @@
-Metadata-Version: 2.4
-Name: cosmol-viewer
-Version: 0.1.2.dev5
-Summary: Molecular visualization tools
-Author-email: 95028 <wjt@cosmol.org>
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Repository, https://github.com/COSMol-repl/COSMol-viewer
-
-# COSMol-viewer
-
-<div align="center">
-  <a href="https://crates.io/crates/cosmol_viewer">
-    <img src="https://img.shields.io/crates/v/cosmol_viewer.svg" alt="crates.io Latest Release"/>
-  </a>
-  <a href="https://pypi.org/project/cosmol_viewer/">
-    <img src="https://img.shields.io/pypi/v/cosmol_viewer.svg" alt="PyPi Latest Release"/>
-  </a>
-</div>
-
-A high-performance molecular visualization library built with Rust and WebGPU, designed for seamless integration into Python workflows.
-
-- ⚡ Fast: Native-speed rendering powered by Rust and GPU acceleration
-
-- 🧬 Flexible: Load molecules from .sdf, .pdb, and dynamically update 3D structures
-
-- 📓 Notebook-friendly: Fully supports Jupyter and Google Colab — ideal for education, research, and live demos
-
-- 🔁 Real-time updates: Update molecular coordinates on-the-fly for simulations or animations
-
-- 🎨 Customizable: Control styles, camera, and rendering settings programmatically
-
-# Installation
-
-```sh
-pip install cosmol-viewer
-```
-
-# Examples
-
-See examples in [Google Colab](https://colab.research.google.com/drive/1Sw72QWjQh_sbbY43jGyBOfF1AQCycmIx?usp=sharing).
-
-# Usage
-
-```python
-from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
-
-# === Step 1: Load and render a molecule ===
-with open("molecule.sdf", "r") as f:
-    sdf = f.read()
-    mol = Molecules(parse_sdf(sdf)).centered()
-
-scene = Scene()
-scene.scale(0.1)
-scene.add_shape(mol, "mol")
-
-viewer = Viewer.render(scene)  # Launch the viewer
-
-# === Step 2: Update the same molecule dynamically ===
-import time
-
-for i in range(1, 10):  # Simulate multiple frames
-    with open(f"frames/frame_{i}.sdf", "r") as f:
-        sdf = f.read()
-        updated_mol = Molecules(parse_sdf(sdf)).centered()
-
-    scene.update_shape("mol", updated_mol)
-    viewer.update(scene)
-
-    time.sleep(0.033)  # ~30 FPS
-```

cosmol_viewer-0.1.2.dev5.dist-info/RECORD

@@ -1,5 +0,0 @@
-cosmol_viewer-0.1.2.dev5.dist-info/METADATA,sha256=mItC7QaLVwxiP0EMtO16NA0EJlsXO15bv7Wnvy3FlOk,2116
-cosmol_viewer-0.1.2.dev5.dist-info/WHEEL,sha256=7HjpuF5o5lgtMF3pBy6MlpnMVqynhBW3YA6IoSreuqI,104
-cosmol_viewer/__init__.py,sha256=K33zoYpHqUVvpFdMVxmCtw4uKj9ZXrGuQD4D4DuUmjk,135
-cosmol_viewer/cosmol_viewer.abi3.so,sha256=TWd_W03e5sG3Aj1OoehjvPkzlbnXA0qiRv3Y515B1FM,14427304
-cosmol_viewer-0.1.2.dev5.dist-info/RECORD,,