rubyx-py 0.1.1-x86_64-linux → 0.2.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca0864297681b8f325cee2c21e955b43107bde5141038af1cf32773025a62d4
-  data.tar.gz: 6c7c9eb14f2a96f28597a734082bfb832754cbe815a51cd83b6be9771238e49e
+  metadata.gz: b8951867f0b79a0a42332ed2ab96c8473847d306f056f50216a791e9c7455ea8
+  data.tar.gz: 108ff5e86840e1c1f6162bdf1c35a5bde636ec66d5bcbe884f562c15487ec91e
 SHA512:
-  metadata.gz: cc5ef7cec35f850ae82f0286879628fc6f82d7a8655322b6c76fab2086e29b2ae6be681ef9dcd516c525b918856d7f86960002fc0d099536cb0b4171e87cb2cc
-  data.tar.gz: 0f27583ac834a7496f9089690ee9f9c7510e0267b3ebe4534e7d29cfffdaf5dc498711b3095272725ec120196cd778b85e492a0a175c94a2522eb58b97982e18
+  metadata.gz: 6ad0bc5de37ee7224751a605ce524b44e655a0c20a0683c3a410f8988d9b7259a7df47543de2669aa11ebc844e35e551f47da9c1177c2abdca32753caae5f197
+  data.tar.gz: 34adc99306f4b9b191a618fdf73da224d39ccf948a91b725600fac1c802639412da459609bb0cee392d73657966c5b930924f915d63bb9fcca9c3cbf2215d103

data/README.md

@@ -1,12 +1,14 @@
 <div align="center">
 
+<img src="docs/assets/logo.png" alt="rubyx-py" width="200">
+
 # Rubyx-py
 
 **Call Python from Ruby. No microservices, no REST APIs, no serialization overhead.**
 
 Powered by Rust for safety and performance. Built for Rails.
 
-[![Gem Version](https://badge.fury.io/rb/rubyx.svg)](https://badge.fury.io/rb/rubyx)
+[![Gem Version](https://badge.fury.io/rb/rubyx-py.svg)](https://badge.fury.io/rb/rubyx-py)
 [![CI](https://github.com/yinho999/rubyx/actions/workflows/ci.yml/badge.svg)](https://github.com/yinho999/rubyx/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.0-red.svg)](https://www.ruby-lang.org)
@@ -34,15 +36,17 @@ Rubyx.stream(llm.generate("Tell me about Ruby")).each { |token| print token }
 # Non-blocking — Ruby stays free while Python works
 future = Rubyx.async_await("model.predict(data)", data: [1, 2, 3])
 do_other_work()
-result = future.value # get result when ready
+result = future.await # GVL released during wait, reacquired when ready
 ```
 
 ### Built with non-blocking in mind
 
 - **`Rubyx.stream`** / **`Rubyx.nb_stream`** — release Ruby's GVL during iteration, other threads and Fibers keep
   running
-- **`Rubyx.async_await`** — spawns Python on background threads, returns a `Future` immediately
-- **`Rubyx.await`** — blocks only when you choose to
+- **`Rubyx.async_await`** — spawns Python on background threads, returns a `Future` immediately; `future.await` releases
+  the GVL while waiting, reacquires when ready
+- **`Rubyx.await`** — GVL released while waiting; returns native Ruby types for primitives, `RubyxObject` for complex
+  Python objects
 
 Ideal for LLM streaming, ML inference, data pipelines, and high-concurrency Rails apps.
 
@@ -88,20 +92,27 @@ dependencies = []
 ### 1. Sync — call a Python function
 
 ```python
-# app/python/hello.py
-def greet(name):
-    return f"Hello, {name}!"
+# app/python/example.py
+def hello(name="World"):
+    return f"Hello, {name}! From Python."
 ```
 
 ```ruby
+
 class GreetingsController < ApplicationController
-  def show
-    hello = Rubyx.import('hello')
-    render json: { message: hello.greet(params[:name]).to_ruby }
+  def index
+    example = Rubyx.import('example')
+    render json: { message: example.hello(params[:name]).to_ruby }
   end
 end
 ```
 
+```ruby
+Rails.application.routes.draw do
+  root "greetings#index"
+end
+```
+
 ### 2. Streaming — iterate a Python generator
 
 ```python
@@ -112,6 +123,7 @@ def count_up(n):
 ```
 
 ```ruby
+
 class CountController < ApplicationController
   include ActionController::Live
 
@@ -141,6 +153,7 @@ async def delayed_greet(name, seconds=1):
 ```
 
 ```ruby
+
 class TasksController < ApplicationController
   def show
     tasks = Rubyx.import('tasks')
@@ -148,7 +161,7 @@ class TasksController < ApplicationController
     # Non-blocking — returns a Future immediately
     future = Rubyx.async_await(tasks.delayed_greet(params[:name], seconds: 2))
     do_other_work()
-    render json: { message: future.value.to_ruby }
+    render json: { message: future.await.to_ruby }
   end
 end
 ```
@@ -263,6 +276,7 @@ end
 ```
 
 ```ruby
+
 class ChatController < ApplicationController
   include ActionController::Live
 
@@ -378,13 +392,13 @@ ctx = Rubyx.context
 ctx.eval("import asyncio")
 ctx.eval("async def fetch(url): ...")
 
-# Blocking
+# GVL released while waiting, reacquired when ready
 result = ctx.await("fetch(url)", url: "https://example.com")
 
 # Non-blocking (returns Future)
 future = ctx.async_await("fetch(url)", url: "https://example.com")
 do_other_stuff()
-result = future.value # blocks only when needed
+result = future.await #  GVL released during wait, reacquired when ready
 future.ready? # check without blocking
 ```
 
@@ -433,17 +447,17 @@ svc.Analyzer([1, 2, 3]).summary.to_ruby # => {"count" => 3, "sum" => 6}
 
 ## API Reference
 
-| Method                               | Description                     |
-|--------------------------------------|---------------------------------|
-| `Rubyx.uv_init(toml, **opts)`        | Setup Python env and initialize |
-| `Rubyx.import(name)`                 | Import a Python module          |
-| `Rubyx.eval(code, **globals)`        | Evaluate Python code            |
-| `Rubyx.await(code, **globals)`       | Run async code (blocking)       |
-| `Rubyx.async_await(code, **globals)` | Run async code (returns Future) |
-| `Rubyx.stream(iterable)`             | Stream a Python generator       |
-| `Rubyx.nb_stream(iterable)`          | Non-blocking stream (GVL-aware) |
-| `Rubyx.context`                      | Create isolated Python context  |
-| `Rubyx.initialized?`                 | Check if Python is ready        |
+| Method                               | Description                                   |
+|--------------------------------------|-----------------------------------------------|
+| `Rubyx.uv_init(toml, **opts)`        | Setup Python env and initialize               |
+| `Rubyx.import(name)`                 | Import a Python module                        |
+| `Rubyx.eval(code, **globals)`        | Evaluate Python code                          |
+| `Rubyx.await(code, **globals)`       | Run async code (GVL released while waiting)   |
+| `Rubyx.async_await(code, **globals)` | Run async code (non-blocking, returns Future) |
+| `Rubyx.stream(iterable)`             | Stream a Python generator                     |
+| `Rubyx.nb_stream(iterable)`          | Non-blocking stream (GVL-aware)               |
+| `Rubyx.context`                      | Create isolated Python context                |
+| `Rubyx.initialized?`                 | Check if Python is ready                      |
 
 | RubyxObject              |                               |
 |--------------------------|-------------------------------|

data/lib/rubyx/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Rubyx
-  VERSION = "0.1.1".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyx-py
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: x86_64-linux
 authors:
 - Naiker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -47,6 +47,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- docs/assets/logo.png
 - ext/rubyx/src/python/sync_adapter.py
 - lib/generators/rubyx/install_generator.rb
 - lib/generators/rubyx/templates/example.py