reactxpy 0.1.0__tar.gz

reactxpy-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include src/*.cpp
+include src/*.h

reactxpy-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: reactxpy
+Version: 0.1.0
+Summary: ReactXPy compiler for web applications.
+Author: Anish Kumar
+Dynamic: author
+Dynamic: summary

reactxpy-0.1.0/README.md

@@ -0,0 +1,152 @@
+# 🚀 ReactXPy (Python Syntax for React)
+
+Welcome to **ReactXPy**, a revolutionary framework that bridges the elegance of Python with the raw power of the React component ecosystem. ReactXPy is an ultra-fast, C++ based transpiler that allows developers to write feature-rich, interactive web applications using clean and readable Python syntax, entirely eliminating the configuration hell of modern JavaScript bundles.
+
+If you love Python's indentation-based readability but need the dynamic, component-driven architecture of React, ReactXPy gives you both without needing Webpack, Vite, Babel, or Node.js running on your machine.
+
+---
+
+## ✨ Core Features (v2)
+
+- **Pure Python Syntax for Components:** Define your UI components using standard `def ComponentName(props):` definitions, free of brackets and JavaScript boilerplate.
+- **Native Inline JSX:** Seamlessly blend standard HTML/JSX tags directly inside your Python functions. The C++ parser intelligently distinguishes Python control flow from DOM declarations.
+- **State & Hooks Engine (NEW):** ReactXPy v2 natively supports React Hooks! Utilize `useState` and `useEffect` with standard Python assignments and lambdas.
+- **Dynamic Props & Interpolation:** Pass data across components naturally using `{props.value}` syntax. Evaluate complex math or logic inside interpolations instantly.
+- **Native Event Handling:** Bind Python functions directly to DOM events like `onClick={triggerFunc}` without dealing with `this` binding or context scoping.
+- **Powerful Conditional Rendering:** Drive UI states with intuitive boolean logic such as `{isActive && <div class="badge">Online</div>}` right inside the tree.
+- **Zero-Dependency CLI Scaffold:** Get started in zero seconds. The built-in `create-reactxpy-app` generator instantly architectures a complete project for you.
+- **Cross-Platform C++ Core:** The transpiler is compiled natively onto your machine (Windows `.exe`, macOS, or Linux) enabling lightning-fast, concurrent build times.
+- **Local Dev Server Hook:** ReactXPy ships with a multi-threaded, hot-reloading native Python watcher (`dev.py`), replacing the need for NPM servers.
+
+---
+
+## 📦 Installation
+
+ReactXPy is distributed globally via standard Python pip packages. Before beginning, ensure you are running Python 3.7+.
+
+To install the framework globally onto your machine:
+
+```bash
+pip install reactxpy
+```
+
+Verify your installation was successful and the native C++ binary was compiled by checking the CLI tool:
+
+```bash
+reactxpy --version
+# Output: reactxpy version 0.1.0
+```
+
+---
+
+## 🛠️ Quick Start
+
+ReactXPy ships with a state-of-the-art interactive CLI to generate standalone applications mimicking the best practices of modern frontend development.
+
+1. **Scaffold a Project**
+   Run the project generator from anywhere in your terminal:
+
+   ```bash
+   create-reactxpy-app my-awesome-app
+   ```
+
+2. **Launch the Live Server**
+   Navigate into your new application and execute the pure-Python hot reloader:
+   ```bash
+   cd my-awesome-app
+   python3 dev.py
+   ```
+
+**That's it!** The `dev.py` script automatically watches your `src/` directory for filesystem changes. It instantly hot-recompiles your `.reactxpy` components into deeply-linked browser-safe Javascript bundles (`dist/bundle.js`) and serves it live at `http://localhost:3000`.
+
+---
+
+## 📖 Comprehensive Syntax Guide
+
+### 1. Components & Standard JSX
+
+ReactXPy treats components naturally. You declare them identically to standard Python functions. When you return HTML DOM tags, the compiler natively intercepts it and translates the structure into optimized `React.createElement` syntax trees.
+
+```python
+# Greet.reactxpy
+def Greet(name):
+    return <div class="greeting-card">
+        <h3>Hello {name}!</h3>
+        <p>Welcome to the ReactXPy ecosystem.</p>
+    </div>
+```
+
+### 2. State Hooks (`useState` & `useEffect`)
+
+ReactXPy v2 fully embraces the React runtime. You can manage encapsulated component states easily by destructuring `useState` tuples, and orchestrate browser lifecycle features like API calls or Local Storage using `useEffect`.
+
+```python
+# CounterApp.reactxpy
+def CounterApp():
+    # Native Python Tuple Destructuring
+    count, setCount = useState(0)
+
+    # Persist the count to the browser's storage whenever the `count` dependency updates
+    useEffect(lambda: localStorage.setItem("clicks", JSON.stringify(count)), [count])
+
+    def triggerIncrement():
+        setCount(count + 1)
+
+    return <div class="counter-panel">
+        <p>Total Clicks: {count}</p>
+        <button onClick={triggerIncrement}>Increment Value</button>
+    </div>
+```
+
+### 3. Conditional UI & Component Composition
+
+ReactXPy supports infinitely nested component architectures. You can import modules seamlessly without Node syntax. It also securely translates HTML attributes (like `class`) into DOM-safe syntax (`className`) automatically.
+
+```python
+# App.reactxpy
+import CounterApp
+
+def App():
+    isAdmin = True
+
+    return <main class="dashboard-wrapper">
+        <h1>Admin Control Panel</h1>
+
+        {isAdmin && <div class="secure-badge">Verified Session</div>}
+
+        <div class="widgets">
+            <CounterApp />
+        </div>
+    </main>
+```
+
+---
+
+## ⚙️ How the Architecture Works
+
+1. **Native OS Compilation:** When you `pip install reactxpy`, your computer leverages its local `g++` compiler to build a hyper-optimized `.exe` (Windows) or binary (Unix) of the ReactXPy transpiler directly within your Python packages folder.
+2. **Lexical Analysis Engine:** The C++ compiler scans your `.reactxpy` files. It fundamentally understands the boundary between Python variable assignments, indentations, scopes, and HTML tag delimiters.
+3. **AST Transpilation:** The framework safely merges Javascript operators (like `||` and `&&`), mathematical calculations, and JSX scopes into raw, standalone Javascript mappings.
+4. **Dependency-Free Bundle:** The compiler bridges your states via a lightweight `runtime.js` hook memory wrapper. It drops ES module syntax entirely—so you don't even need a server! You can double-click `index.html` directly from a USB stick and the app will flawlessly function offline in standard browsers.
+
+---
+
+## 🔮 Development Roadmap
+
+ReactXPy is an actively maintained open-source framework. The current horizon features include:
+
+- [x] Transpilation of Standard JSX directly to `React` API calls.
+- [x] Interactive State Management (`useState` Hooks).
+- [x] Application Lifecycle Memory (`useEffect` Hooks).
+- [x] Zero-Dependency Build Pipelines (`build.py` & `dev.py`).
+- [x] Native Microsoft Windows (`.exe`) Subprocess Compilation.
+- [ ] List Comprehension Syntax (e.g., `<item for item in array>`).
+- [ ] Asynchronous API Fetching (`async/await` components).
+- [ ] Deep Integrated Server-Side Python Routing.
+
+---
+
+
+### License
+
+MIT License - Have fun building!

reactxpy-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

reactxpy-0.1.0/reactxpy/cli.py

@@ -0,0 +1,36 @@
+import os
+import sys
+import subprocess
+
+def main():
+    # Handle version flags directly in the wrapper
+    if len(sys.argv) > 1 and sys.argv[1] in ["-v", "--version"]:
+        print("reactxpy version 0.1.0")
+        sys.exit(0)
+
+    # Find the compiled C++ compiler binary relative to this script
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    is_windows = sys.platform == "win32"
+    binary_name = "reactxpy_compiler.exe" if is_windows else "reactxpy_compiler"
+    compiler_path = os.path.join(current_dir, binary_name)
+    
+    if not os.path.exists(compiler_path):
+        print(f"Error: ReactXPy compiler binary not found at {compiler_path}")
+        print("Please ensure the package was built correctly.")
+        sys.exit(1)
+
+    # Pass all arguments directly to the C++ compiler
+    args = [compiler_path] + sys.argv[1:]
+    
+    try:
+        # Replaces the current process with the compiler
+        if is_windows:
+            sys.exit(subprocess.call(args))
+        else:
+            os.execv(compiler_path, args)
+    except OSError as e:
+        print(f"Failed to execute compiler: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

reactxpy-0.1.0/reactxpy/create_app.py

@@ -0,0 +1,375 @@
+import os
+import sys
+
+def create_file(path, content):
+    with open(path, 'w') as f:
+        f.write(content.strip() + '\n')
+    print(f"Created {path}")
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] in ["-h", "--help"]:
+        print("Usage: create-reactxpy-app [project-name]")
+        print("\\nOptions:")
+        print("  -h, --help       Show this help message and exit.")
+        print("  -v, --version    Show the version of create-reactxpy-app.")
+        print("\\nExample:")
+        print("  create-reactxpy-app my-new-project")
+        sys.exit(0)
+
+    if len(sys.argv) > 1 and sys.argv[1] in ["-v", "--version"]:
+        print("create-reactxpy-app version 0.1.0")
+        sys.exit(0)
+
+    print("\\033[0;34mWelcome to create-reactxpy-app! Let's scaffold your new project.\\033[0m\\n")
+
+    project_name = ""
+    if len(sys.argv) > 1:
+        project_name = sys.argv[1]
+        
+    while not project_name:
+        try:
+            project_name = input("? What is your project named? ")
+        except (KeyboardInterrupt, EOFError):
+            print("\\nOperation cancelled.")
+            sys.exit(1)
+            
+    project_name = project_name.strip()
+    if not project_name:
+        print("Error: Project name cannot be empty.")
+        sys.exit(1)
+    
+    if os.path.exists(project_name):
+        print(f"Error: Directory '{project_name}' already exists.")
+        sys.exit(1)
+        
+    print(f"\\n🚀 Creating a new ReactXPy project in {os.path.abspath(project_name)}...")
+    
+    # Create directory structure
+    dirs = [
+        project_name,
+        os.path.join(project_name, "public"),
+        os.path.join(project_name, "src"),
+        os.path.join(project_name, "src", "components"),
+        os.path.join(project_name, "runtime")
+    ]
+    
+    for d in dirs:
+        os.makedirs(d, exist_ok=True)
+        
+    # App.pysx
+    app_pysx = """
+import CounterApp
+
+def App():
+    isAdmin = true
+
+    return <main class="dashboard-wrapper">
+        <h1>Admin Control Panel</h1>
+        
+        {isAdmin && <div class="secure-badge">Verified Session</div>}
+        
+        <div class="widgets">
+            <CounterApp />
+        </div>
+    </main>
+"""
+
+    # CounterApp.pysx
+    counterapp_pysx = """
+def CounterApp():
+    count, setCount = useState(0)
+
+    useEffect(lambda: localStorage.setItem("clicks", JSON.stringify(count)), [count])
+
+    return <div class="counter-panel">
+        <p>Total Clicks: {count}</p>
+        <button onClick={lambda: setCount(count + 1)}>Increment Value</button>
+    </div>
+"""
+
+    # runtime.js
+    runtime_js = """
+// runtime/runtime.js
+
+// -----------------------------
+// Hook wrappers (simple bridge)
+// -----------------------------
+function useState(initial) {
+  return React.useState(initial);
+}
+
+function useEffect(effect, deps) {
+  return React.useEffect(effect, deps);
+}
+
+// -----------------------------
+// App runner
+// -----------------------------
+function run(App) {
+
+  const rootElement =
+    document.getElementById("root") ||
+    document.body;
+
+  const root = ReactDOM.createRoot(rootElement);
+
+  root.render(
+    React.createElement(App)
+  );
+}
+
+// -----------------------------
+// Global API
+// -----------------------------
+window.ReactXPy = {
+  run,
+  useState,
+  useEffect
+};
+"""
+
+    # index.html
+    index_html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>ReactXPy App</title>
+    <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
+    <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
+    <link rel="stylesheet" href="./style.css">
+</head>
+<body>
+    <div id="root"></div>
+    <script src="../runtime/runtime.js"></script>
+    <script src="../dist/bundle.js"></script>
+    <script>
+        ReactXPy.run(App);
+        
+        // Live Reload Hook
+        let currentVersion = null;
+        setInterval(() => {
+            fetch('/version').then(res => res.text()).then(version => {
+                if (currentVersion === null) currentVersion = version;
+                else if (currentVersion !== version) location.reload();
+            }).catch(() => {});
+        }, 1000);
+    </script>
+</body>
+</html>
+"""
+
+    # style.css
+    style_css = """
+:root {
+    --bg-main: #f8fafc;
+    --card-bg: #ffffff;
+    --text-primary: #0f172a;
+    --text-secondary: #64748b;
+    --accent: #4f46e5;
+    --accent-hover: #4338ca;
+    --success-bg: #dcfce7;
+    --success-text: #166534;
+}
+
+body {
+    margin: 0;
+    font-family: 'Inter', system-ui, -apple-system, sans-serif;
+    background-color: var(--bg-main);
+    color: var(--text-primary);
+    display: flex;
+    justify-content: center;
+    padding-top: 60px;
+}
+
+.dashboard-wrapper {
+    background: var(--card-bg);
+    padding: 40px;
+    border-radius: 16px;
+    box-shadow: 0 10px 25px rgba(0,0,0,0.05);
+    text-align: center;
+    max-width: 400px;
+    width: 100%;
+}
+
+h1 {
+    font-size: 1.5rem;
+    margin-top: 0;
+    margin-bottom: 12px;
+}
+
+.secure-badge {
+    display: inline-block;
+    background: var(--success-bg);
+    color: var(--success-text);
+    padding: 6px 12px;
+    border-radius: 20px;
+    font-size: 0.85rem;
+    font-weight: 600;
+    margin-bottom: 30px;
+}
+
+.counter-panel {
+    background: #f1f5f9;
+    padding: 24px;
+    border-radius: 12px;
+}
+
+.counter-panel p {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin-top: 0;
+    color: var(--text-secondary);
+}
+
+button {
+    background: var(--accent);
+    color: white;
+    border: none;
+    padding: 12px 24px;
+    border-radius: 8px;
+    font-weight: 600;
+    font-size: 1rem;
+    cursor: pointer;
+    transition: 0.2s;
+    width: 100%;
+}
+
+button:hover {
+    background: var(--accent-hover);
+    transform: translateY(-2px);
+}
+"""
+
+    # build.py
+    build_py = """
+import os
+import subprocess
+from pathlib import Path
+
+def main():
+    print("🚀 Building ReactXPy App...")
+    
+    os.makedirs("dist", exist_ok=True)
+    compiled_files = []
+    
+    from shutil import which
+    if which("reactxpy") is None:
+        print("❌ Error: reactxpy compiler not found. Please install the reactxpy pip package globally.")
+        return
+        
+    for file in Path("src").rglob("*.pysx"):
+        basename = file.stem
+        output_path = f"dist/{basename}.js"
+        
+        print(f"⚡ Compiling: {file} -> {output_path}")
+        subprocess.run(["reactxpy", str(file), "-o", output_path], check=True)
+        compiled_files.append(output_path)
+        
+    if compiled_files:
+        print("\\n🔗 Linking into dist/bundle.js...")
+        subprocess.run(["reactxpy", "--bundle"] + compiled_files + ["dist/bundle.js"], check=True)
+        print("\\n✅ Success! Build complete.")
+    else:
+        print("❌ Error: No .pysx files found in src directory.")
+
+if __name__ == "__main__":
+    main()
+"""
+
+    # dev.py
+    dev_py = """
+import os
+import sys
+import time
+import subprocess
+import threading
+from pathlib import Path
+
+BUILD_VERSION = 1
+
+def get_mtimes():
+    mtimes = {}
+    for p in Path("src").rglob("*.pysx"):
+        mtimes[str(p)] = p.stat().st_mtime
+    return mtimes
+
+def serve():
+    from http.server import SimpleHTTPRequestHandler
+    from socketserver import TCPServer
+    
+    class QuietHandler(SimpleHTTPRequestHandler):
+        def log_message(self, format, *args):
+            pass # Keep terminal clean
+            
+        def do_GET(self):
+            if self.path == '/version':
+                self.send_response(200)
+                self.send_header('Content-type', 'text/plain')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                self.wfile.write(str(BUILD_VERSION).encode())
+            else:
+                super().do_GET()
+
+    TCPServer.allow_reuse_address = True
+    try:
+        httpd = TCPServer(("", 3000), QuietHandler)
+        print("🌐 Live Server running at http://localhost:3000/public/index.html")
+        httpd.serve_forever()
+    except OSError as e:
+        print(f"❌ Could not start dev server: {e}")
+        sys.exit(1)
+
+def main():
+    global BUILD_VERSION
+    print("🚀 Starting ReactXPy Live Development Server...")
+    subprocess.run([sys.executable, "build.py"], check=False)
+    
+    server_thread = threading.Thread(target=serve, daemon=True)
+    server_thread.start()
+    
+    print("👀 Watching for file changes in src/ directory...")
+    last_mtimes = get_mtimes()
+    
+    try:
+        while True:
+            time.sleep(0.5)
+            current_mtimes = get_mtimes()
+            
+            if current_mtimes != last_mtimes:
+                print("\\n✨ File change detected! Rebuilding...")
+                subprocess.run([sys.executable, "build.py"], check=False)
+                last_mtimes = current_mtimes
+                BUILD_VERSION += 1
+                
+    except KeyboardInterrupt:
+        print("\\n🛑 Stopping dev server...")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+"""
+
+    create_file(os.path.join(project_name, "src", "App.pysx"), app_pysx)
+    create_file(os.path.join(project_name, "src", "components", "CounterApp.pysx"), counterapp_pysx)
+    create_file(os.path.join(project_name, "runtime", "runtime.js"), runtime_js)
+    create_file(os.path.join(project_name, "public", "index.html"), index_html)
+    create_file(os.path.join(project_name, "public", "style.css"), style_css)
+    
+    build_script = os.path.join(project_name, "build.py")
+    create_file(build_script, build_py)
+    
+    dev_script = os.path.join(project_name, "dev.py")
+    create_file(dev_script, dev_py)
+    
+    os.chmod(build_script, 0o755) # Make executable
+    os.chmod(dev_script, 0o755)
+    
+    print(f"\\n✅ Project '{project_name}' created successfully!")
+    print("\\nNext steps:")
+    print(f"  cd {project_name}")
+    print("  python3 dev.py")
+
+if __name__ == "__main__":
+    main()

reactxpy-0.1.0/reactxpy.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: reactxpy
+Version: 0.1.0
+Summary: ReactXPy compiler for web applications.
+Author: Anish Kumar
+Dynamic: author
+Dynamic: summary

reactxpy-0.1.0/reactxpy.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+reactxpy/__init__.py
+reactxpy/cli.py
+reactxpy/create_app.py
+reactxpy.egg-info/PKG-INFO
+reactxpy.egg-info/SOURCES.txt
+reactxpy.egg-info/dependency_links.txt
+reactxpy.egg-info/entry_points.txt
+reactxpy.egg-info/not-zip-safe
+reactxpy.egg-info/top_level.txt
+src/ast.h
+src/generator.cpp
+src/generator.h
+src/lexer.cpp
+src/lexer.h
+src/linker.cpp
+src/linker.h
+src/main.cpp
+src/parser.cpp
+src/parser.h
+src/test_parser.cpp

reactxpy-0.1.0/reactxpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reactxpy-0.1.0/reactxpy.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+create-reactxpy-app = reactxpy.create_app:main
+reactxpy = reactxpy.cli:main

reactxpy-0.1.0/reactxpy.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

reactxpy-0.1.0/reactxpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+reactxpy

reactxpy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+