blinkui 0.1.0__tar.gz

blinkui-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: blinkui
+Version: 0.1.0
+Summary: Build mobile apps in pure Python
+Requires-Python: >=3.10
+Dynamic: requires-python
+Dynamic: summary

blinkui-0.1.0/README.md

@@ -0,0 +1,191 @@
+<div align="center">
+
+# ⚡ BlinkUI
+
+### Build mobile apps in pure Python
+
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://python.org)
+[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Platform](https://img.shields.io/badge/Platform-iOS%20%7C%20Android-lightgrey.svg)]()
+
+</div>
+
+---
+
+## What is BlinkUI?
+
+BlinkUI is a mobile app framework for Python developers. Write your app in pure Python and ship it to iOS and Android. No Swift, no Kotlin, no JavaScript.
+```python
+from blinkui import Screen, state
+from blinkui.components import VStack, Text, Button, Heading
+
+class HomeScreen(Screen):
+    count = state(0)
+
+    def build(self):
+        return VStack(
+            Heading("Hello from BlinkUI"),
+            Text(f"Count: {self.count}").size(48).bold(),
+            Button("Tap Me").on_tap(self.increment),
+        ).spacing(16).padding(24)
+
+    def increment(self):
+        self.count += 1
+```
+
+---
+
+## Why BlinkUI?
+
+| | BlinkUI | React Native | Flutter |
+|---|---|---|---|
+| Language | **Python** | JavaScript | Dart |
+| Python ecosystem | **✅ Full access** | ❌ | ❌ |
+| AI/ML libraries | **✅ pandas, numpy** | ❌ | ❌ |
+| Native UI | ✅ | ✅ | ❌ |
+| Hot reload | ✅ | ✅ | ✅ |
+
+---
+
+## Getting started
+```bash
+pip install blinkui
+blink new myapp
+cd myapp
+blink run
+```
+
+---
+
+## Architecture
+
+BlinkUI is built in two layers:
+
+**C Runtime** — a fast native engine inspired by Facebook's Hermes:
+- Node tree — every UI element represented in memory
+- Reconciler — diffs component trees, patches only what changed
+- Event system — catches native interactions, fires Python callbacks
+- Animation engine — 60fps animations running entirely in C
+- CPython host — embeds Python inside iOS and Android
+
+**Python Framework** — what developers write in:
+- `state()` — declare reactive variables, UI updates automatically
+- `Screen` — base class for every screen
+- `Router` — navigation stack with data passing
+- `Theme` — iOS-inspired design system with dark mode
+- HTTP client — async requests that never freeze the UI
+- Async storage — persistent key-value storage
+
+---
+
+## Components
+```python
+from blinkui.components import (
+    # Layout
+    VStack, HStack, ZStack, ScrollView, Spacer,
+
+    # Text
+    Text, Heading, Label, Badge,
+
+    # Input
+    Button, TextField, Toggle, Slider,
+
+    # Display
+    Card, Image, Avatar, Modal, BottomSheet,
+
+    # Navigation
+    TabBar, NavigationBar, Toast,
+)
+```
+
+---
+
+## HTTP and AI backend
+
+BlinkUI apps connect to Python backends via HTTP:
+```python
+from blinkui.http import get, post, set_base_url, set_token
+
+class DashboardScreen(Screen):
+    data = state(None)
+
+    async def on_mount(self):
+        response = await get("https://api.myapp.com/data")
+        if response.ok:
+            self.data = response.data
+        else:
+            self.error = response.error
+```
+
+Your AI and ML code lives on the server — pandas, tensorflow, pytorch — and your BlinkUI app calls it via API. Mobile stays fast. Python stays powerful.
+
+---
+
+## Storage
+```python
+from blinkui.storage import storage
+
+# save
+await storage.set("token", "abc123")
+
+# get
+token = await storage.get("token")
+
+# delete
+await storage.delete("token")
+```
+
+---
+
+## CLI
+```bash
+blink new myapp          # create a new app
+blink run                # run on simulator
+blink run --hot          # hot reload
+blink install pandas     # install packages
+blink build ios          # build for App Store
+blink build android      # build for Play Store
+```
+
+---
+
+## Project structure
+```
+myapp/
+├── main.py              # entry point
+├── blink.toml           # project config
+├── screens/
+│   ├── home.py
+│   └── detail.py
+├── components/
+└── assets/
+```
+
+---
+
+## Roadmap
+
+- [x] C runtime — node tree, reconciler, events, animations
+- [x] CPython embedding on mobile
+- [x] Python framework — state, screen, router, theme
+- [x] Component library
+- [x] HTTP client
+- [x] Async storage
+- [x] CLI tool
+- [ ] Android native bridge
+- [ ] Hot reload on device
+- [ ] PyPI publish
+- [ ] iOS bridge
+- [ ] Documentation site
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.
+
+---
+
+<div align="center">
+Built with Python and C by the BlinkUI team
+</div>

blinkui-0.1.0/blinkui/__init__.py

@@ -0,0 +1,7 @@
+from .app    import App
+from .screen import Screen
+from .state  import state
+from .router import Router
+from .theme  import Theme, get_theme, set_theme
+
+__all__ = ["App", "Screen", "state", "Router", "Theme", "get_theme", "set_theme"]

blinkui-0.1.0/blinkui/app.py

@@ -0,0 +1,30 @@
+from .screen import Screen
+
+
+class App:
+    """
+    Entry point for every BlinkUI app.
+
+    Usage:
+        from blinkui import App
+        from screens.home import HomeScreen
+
+        App(entry=HomeScreen).run()
+    """
+
+    def __init__(self, entry, theme=None):
+        self._entry  = entry
+        self._theme  = theme
+        self._screen = None
+
+    def run(self):
+        print("[App] BlinkUI starting...")
+
+        # instantiate the entry screen
+        self._screen = self._entry()
+
+        # mount and render
+        self._screen.on_mount()
+        self._screen._render()
+
+        print("[App] App running")

blinkui-0.1.0/blinkui/components/__init__.py

@@ -0,0 +1,24 @@
+from .layout     import VStack, HStack, ZStack, ScrollView, Spacer, Divider
+from .text       import Text, Heading, Label, Badge
+from .button     import Button, IconButton
+from .image      import Image, Avatar
+from .input      import TextField, Toggle, Slider, Picker
+from .card       import Card, Skeleton, Modal, BottomSheet
+from .navigation import TabBar, Tab, NavigationBar, Toast
+
+__all__ = [
+    # layout
+    "VStack", "HStack", "ZStack", "ScrollView", "Spacer", "Divider",
+    # text
+    "Text", "Heading", "Label", "Badge",
+    # button
+    "Button", "IconButton",
+    # image
+    "Image", "Avatar",
+    # input
+    "TextField", "Toggle", "Slider", "Picker",
+    # card
+    "Card", "Skeleton", "Modal", "BottomSheet",
+    # navigation
+    "TabBar", "Tab", "NavigationBar", "Toast",
+]

blinkui-0.1.0/blinkui/components/base.py

@@ -0,0 +1,159 @@
+# ─────────────────────────────────────────
+# Base component
+# Every BlinkUI component inherits from this
+# ─────────────────────────────────────────
+
+class Component:
+    """
+    Base class for all BlinkUI components.
+    Supports method chaining for styling.
+    """
+
+    def __init__(self, *children):
+        self._children        = list(children)
+        self._font_size       = 16
+        self._bold            = False
+        self._italic          = False
+        self._color           = None
+        self._background      = None
+        self._width           = None
+        self._height          = None
+        self._padding         = [0, 0, 0, 0]  # top right bottom left
+        self._margin          = [0, 0, 0, 0]
+        self._corner_radius   = 0
+        self._opacity         = 1.0
+        self._visible         = True
+        self._on_tap          = None
+        self._on_change       = None
+        self._spacing         = 8
+        self._align           = "start"
+        self._animation       = None
+
+    # ── Styling methods — all return self for chaining ──
+
+    def size(self, font_size):
+        self._font_size = font_size
+        return self
+
+    def bold(self, value=True):
+        self._bold = value
+        return self
+
+    def italic(self, value=True):
+        self._italic = value
+        return self
+
+    def color(self, color):
+        self._color = color
+        return self
+
+    def background(self, color):
+        self._background = color
+        return self
+
+    def width(self, value):
+        self._width = value
+        return self
+
+    def height(self, value):
+        self._height = value
+        return self
+
+    def padding(self, top=0, right=None, bottom=None, left=None):
+        # support padding(16) for all sides
+        if right is None:
+            right = bottom = left = top
+        elif bottom is None:
+            bottom = top
+            left   = right
+        self._padding = [top, right, bottom, left]
+        return self
+
+    def margin(self, top=0, right=None, bottom=None, left=None):
+        if right is None:
+            right = bottom = left = top
+        elif bottom is None:
+            bottom = top
+            left   = right
+        self._margin = [top, right, bottom, left]
+        return self
+
+    def corner_radius(self, value):
+        self._corner_radius = value
+        return self
+
+    def round(self, value=999):
+        self._corner_radius = value
+        return self
+
+    def opacity(self, value):
+        self._opacity = value
+        return self
+
+    def visible(self, value=True):
+        self._visible = value
+        return self
+
+    def spacing(self, value):
+        self._spacing = value
+        return self
+
+    def align(self, value):
+        # "start" "center" "end"
+        self._align = value
+        return self
+
+    def center(self):
+        self._align = "center"
+        return self
+
+    # ── Event methods ──
+
+    def on_tap(self, callback):
+        self._on_tap = callback
+        return self
+
+    def on_change(self, callback):
+        self._on_change = callback
+        return self
+
+    # ── Animation ──
+
+    def animate(self, duration=300, curve="easeOut", **props):
+        self._animation = {
+            "duration": duration,
+            "curve":    curve,
+            "props":    props
+        }
+        return self
+
+    # ── Serialization ──
+    # Converts component tree to dict
+    # C runtime reads this dict to build native views
+
+    def to_dict(self):
+        return {
+            "type":          self.__class__.__name__,
+            "font_size":     self._font_size,
+            "bold":          self._bold,
+            "italic":        self._italic,
+            "color":         self._color,
+            "background":    self._background,
+            "width":         self._width,
+            "height":        self._height,
+            "padding":       self._padding,
+            "margin":        self._margin,
+            "corner_radius": self._corner_radius,
+            "opacity":       self._opacity,
+            "visible":       self._visible,
+            "spacing":       self._spacing,
+            "align":         self._align,
+            "animation":     self._animation,
+            "children": [
+                c.to_dict() if isinstance(c, Component) else str(c)
+                for c in self._children
+            ]
+        }
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} children={len(self._children)}>"

blinkui-0.1.0/blinkui/components/button.py

@@ -0,0 +1,44 @@
+from .base import Component
+
+
+class Button(Component):
+    """
+    Tappable button.
+
+    Usage:
+        Button("Get Started").on_tap(self.handle_tap)
+        Button("Delete").color("#FF3B30").on_tap(self.delete)
+    """
+    def __init__(self, label=""):
+        super().__init__()
+        self._label      = str(label)
+        self._background = "#007AFF"   # iOS blue
+        self._color      = "#FFFFFF"
+        self._font_size  = 16
+        self._bold       = True
+        self._corner_radius = 12
+        self._padding    = [14, 20, 14, 20]
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["label"] = self._label
+        return d
+
+
+class IconButton(Component):
+    """
+    Button with just an icon.
+
+    Usage:
+        IconButton("heart").on_tap(self.like)
+    """
+    def __init__(self, icon=""):
+        super().__init__()
+        self._icon       = icon
+        self._background = "transparent"
+        self._color      = "#007AFF"
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["icon"] = self._icon
+        return d

blinkui-0.1.0/blinkui/components/card.py

@@ -0,0 +1,132 @@
+from .base import Component
+
+
+class Card(Component):
+    """
+    Elevated surface for grouping content.
+    iOS style with subtle shadow and rounded corners.
+
+    Usage:
+        Card(
+            VStack(
+                Text("Title").bold(),
+                Text("Subtitle").color("#8E8E93")
+            )
+        ).padding(16)
+
+        Card(
+            Text("Simple card")
+        ).on_tap(self.handle_tap)
+    """
+
+    def __init__(self, *children):
+        super().__init__(*children)
+        self._background    = "#FFFFFF"
+        self._corner_radius = 12
+        self._padding       = [16, 16, 16, 16]
+        self._shadow        = True
+        self._shadow_color  = "rgba(0,0,0,0.08)"
+        self._shadow_radius = 8
+        self._shadow_offset = [0, 2]
+
+    def shadow(self, value=True):
+        self._shadow = value
+        return self
+
+    def shadow_color(self, color):
+        self._shadow_color = color
+        return self
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["shadow"]        = self._shadow
+        d["shadow_color"]  = self._shadow_color
+        d["shadow_radius"] = self._shadow_radius
+        d["shadow_offset"] = self._shadow_offset
+        return d
+
+
+class Skeleton(Component):
+    """
+    Loading placeholder that animates.
+    Shows while content is being fetched.
+
+    Usage:
+        Skeleton().width(200).height(20)
+        Skeleton().width(150).height(20)
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._background = "#E5E5EA"
+        self._animated   = True
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["animated"] = self._animated
+        return d
+
+
+class Modal(Component):
+    """
+    Full screen overlay modal.
+
+    Usage:
+        Modal(
+            VStack(
+                Heading("Are you sure?"),
+                Button("Confirm").on_tap(self.confirm),
+                Button("Cancel").on_tap(self.dismiss)
+            ),
+            visible=self.show_modal
+        )
+    """
+
+    def __init__(self, *children, visible=False):
+        super().__init__(*children)
+        self._modal_visible = visible
+        self._dismissable   = True
+        self._background    = "#FFFFFF"
+        self._corner_radius = 20
+
+    def dismissable(self, value=True):
+        self._dismissable = value
+        return self
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["modal_visible"] = self._modal_visible
+        d["dismissable"]   = self._dismissable
+        return d
+
+
+class BottomSheet(Component):
+    """
+    Sheet that slides up from the bottom.
+
+    Usage:
+        BottomSheet(
+            VStack(
+                Text("Options"),
+                Button("Share").on_tap(self.share),
+            ),
+            visible=self.show_sheet
+        )
+    """
+
+    def __init__(self, *children, visible=False):
+        super().__init__(*children)
+        self._sheet_visible = visible
+        self._detents       = ["medium", "large"]  # snap points
+        self._background    = "#FFFFFF"
+        self._corner_radius = 20
+
+    def detents(self, *values):
+        self._detents = list(values)
+        return self
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["sheet_visible"] = self._sheet_visible
+        d["detents"]       = self._detents
+        return d

blinkui-0.1.0/blinkui/components/image.py

@@ -0,0 +1,65 @@
+from .base import Component
+
+
+class Image(Component):
+    """
+    Displays an image from a path or URL.
+
+    Usage:
+        Image("avatar.png").size(80).round()
+        Image("https://example.com/photo.jpg").width(200).height(150)
+    """
+
+    def __init__(self, source=""):
+        super().__init__()
+        self._source    = source
+        self._fit       = "cover"   # cover, contain, fill
+        self._alt       = ""
+
+    def fit(self, mode):
+        # "cover" "contain" "fill"
+        self._fit = mode
+        return self
+
+    def alt(self, text):
+        self._alt = text
+        return self
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["source"] = self._source
+        d["fit"]    = self._fit
+        d["alt"]    = self._alt
+        return d
+
+
+class Avatar(Component):
+    """
+    Circular avatar image. Falls back to initials if no image.
+
+    Usage:
+        Avatar("photo.png").size(48)
+        Avatar(initials="JD").size(48).color("#007AFF")
+    """
+
+    def __init__(self, source="", initials=""):
+        super().__init__()
+        self._source   = source
+        self._initials = initials
+        self._size_val = 40
+        self._background = "#007AFF"
+        self._color      = "#FFFFFF"
+
+    def size(self, value):
+        self._size_val       = value
+        self._width          = value
+        self._height         = value
+        self._corner_radius  = value / 2
+        return self
+
+    def to_dict(self):
+        d = super().to_dict()
+        d["source"]   = self._source
+        d["initials"] = self._initials
+        d["size"]     = self._size_val
+        return d