robyn 0.73.0__cp311-cp311-macosx_10_12_x86_64.whl

robyn/__main__.py

@@ -0,0 +1,4 @@
+from robyn.cli import run
+
+if __name__ == "__main__":
+    run()

robyn/ai.py

@@ -0,0 +1,308 @@
+"""
+This is an experimental AI integration module for Robyn framework.
+
+A poc for the blog at https://sanskar.wtf/posts/the-future-of-robyn
+
+Provides agent and memory functionality for building AI-powered applications for the demonstration of the vision mentioned in
+"""
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class AIConfig:
+    """Configuration class for AI providers and settings"""
+
+    def __init__(self, **kwargs):
+        self.config = kwargs
+        self._load_from_env()
+
+    def _load_from_env(self):
+        """Load configuration from environment variables"""
+        env_vars = {
+            "OPENAI_API_KEY": "openai_api_key",
+            "ANTHROPIC_API_KEY": "anthropic_api_key",
+            "GOOGLE_API_KEY": "google_api_key",
+            "AI_MODEL": "model",
+            "AI_TEMPERATURE": "temperature",
+            "AI_MAX_TOKENS": "max_tokens",
+        }
+
+        for env_var, config_key in env_vars.items():
+            if env_var in os.environ and config_key not in self.config:
+                value = os.environ[env_var]
+                # Convert numeric values
+                if config_key in ["temperature", "max_tokens"]:
+                    try:
+                        value = float(value) if config_key == "temperature" else int(value)
+                    except ValueError:
+                        pass
+                self.config[config_key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value"""
+        return self.config.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set configuration value"""
+        self.config[key] = value
+
+    def update(self, **kwargs) -> None:
+        """Update configuration with new values"""
+        self.config.update(kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary"""
+        return self.config.copy()
+
+
+class MemoryProvider(ABC):
+    """Abstract base class for memory providers"""
+
+    @abstractmethod
+    async def store(self, user_id: str, data: Dict[str, Any]) -> None:
+        """Store data in memory"""
+        pass
+
+    @abstractmethod
+    async def retrieve(self, user_id: str, query: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Retrieve data from memory"""
+        pass
+
+    @abstractmethod
+    async def clear(self, user_id: str) -> None:
+        """Clear memory for a user"""
+        pass
+
+
+class InMemoryProvider(MemoryProvider):
+    """Simple in-memory storage provider"""
+
+    def __init__(self):
+        self._storage: Dict[str, List[Dict[str, Any]]] = {}
+
+    async def store(self, user_id: str, data: Dict[str, Any]) -> None:
+        if user_id not in self._storage:
+            self._storage[user_id] = []
+        self._storage[user_id].append(data)
+
+    async def retrieve(self, user_id: str, query: Optional[str] = None) -> List[Dict[str, Any]]:
+        return self._storage.get(user_id, [])
+
+    async def clear(self, user_id: str) -> None:
+        if user_id in self._storage:
+            del self._storage[user_id]
+
+
+class Memory:
+    """Memory interface for storing and retrieving conversation history and context"""
+
+    def __init__(self, provider: Union[str, MemoryProvider], user_id: str, **kwargs):
+        self.user_id = user_id
+
+        if isinstance(provider, str):
+            if provider == "inmemory":
+                self.provider = InMemoryProvider()
+            else:
+                raise ValueError(f"Unknown memory provider: {provider}")
+        else:
+            self.provider = provider
+
+    async def add(self, message: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Add a message to memory"""
+        data = {"message": message, "metadata": metadata or {}}
+        await self.provider.store(self.user_id, data)
+
+    async def get(self, query: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get messages from memory"""
+        return await self.provider.retrieve(self.user_id, query)
+
+    async def clear(self) -> None:
+        """Clear all memory for this user"""
+        await self.provider.clear(self.user_id)
+
+
+class AgentRunner(ABC):
+    """Abstract base class for agent runners"""
+
+    @abstractmethod
+    async def run(self, query: str, **kwargs) -> Dict[str, Any]:
+        """Execute the agent with the given query"""
+        pass
+
+
+class SimpleRunner(AgentRunner):
+    """Simple runner with OpenAI integration and fallback responses"""
+
+    def __init__(self, **config):
+        self.config = AIConfig(**config)
+        self._client = None
+
+    def _get_client(self):
+        """Get OpenAI client if API key is available"""
+        if self._client is None and self.config.get("openai_api_key"):
+            try:
+                import openai
+
+                self._client = openai.OpenAI(api_key=self.config.get("openai_api_key"))
+            except ImportError:
+                raise ImportError("openai package not installed. Install with: pip install openai")
+        return self._client
+
+    async def run(self, query: str, **kwargs) -> Dict[str, Any]:
+        """Execute with OpenAI (requires API key)"""
+        client = self._get_client()
+
+        if not client:
+            raise ValueError("OpenAI API key is required. Set 'openai_api_key' in configuration.")
+
+        try:
+            # Use OpenAI
+            messages = [{"role": "user", "content": query}]
+
+            # Add conversation history
+            context = kwargs.get("context", {})
+            history = context.get("history", [])
+
+            if history:
+                for item in history[-10:]:
+                    msg = item.get("message", str(item))
+                    if msg.startswith("Query: "):
+                        messages.insert(-1, {"role": "user", "content": msg[7:]})
+                    elif msg.startswith("Response: "):
+                        messages.insert(-1, {"role": "assistant", "content": msg[10:]})
+
+            response = client.chat.completions.create(
+                model=self.config.get("model", "gpt-4o"),
+                messages=messages,
+                temperature=self.config.get("temperature", 0.7),
+                max_tokens=self.config.get("max_tokens", 1000),
+            )
+
+            content = response.choices[0].message.content
+            metadata = {
+                "runner_type": "simple_openai",
+                "model": self.config.get("model", "gpt-4o"),
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                },
+            }
+
+            if self.config.get("debug", False):
+                metadata["debug_info"] = {"config": self.config.to_dict()}
+
+            return {"response": content, "query": query, "metadata": metadata}
+
+        except Exception as e:
+            logger.error(f"Error in SimpleRunner: {e}")
+            raise e
+
+
+class Agent:
+    """AI Agent interface for handling queries with memory and execution"""
+
+    def __init__(self, runner: Union[str, AgentRunner], memory: Optional[Memory] = None, **kwargs):
+        self.memory = memory
+
+        if isinstance(runner, str):
+            if runner == "simple":
+                self.runner = SimpleRunner(**kwargs)
+            else:
+                raise ValueError(f"Unknown runner type: {runner}")
+        else:
+            self.runner = runner
+
+    async def run(self, query: str, history: bool = False, **kwargs) -> Dict[str, Any]:
+        """Run the agent with the given query"""
+        context = {}
+
+        if self.memory and history:
+            context["history"] = await self.memory.get()
+
+        # Add context to kwargs
+        if context:
+            kwargs["context"] = context
+
+        # Execute the agent
+        result = await self.runner.run(query, **kwargs)
+
+        # Store the interaction in memory if available
+        if self.memory:
+            await self.memory.add(f"Query: {query}")
+            if "response" in result:
+                await self.memory.add(f"Response: {result['response']}")
+
+        return result
+
+
+def memory(provider: str = "inmemory", user_id: str = "default", **kwargs) -> Memory:
+    """
+    Create a memory instance with the specified provider
+
+    Args:
+        provider: Memory provider type ("inmemory")
+        user_id: User identifier for memory isolation
+        **kwargs: Additional configuration for the provider
+
+    Returns:
+        Memory instance
+    """
+    return Memory(provider=provider, user_id=user_id, **kwargs)
+
+
+def configure(**kwargs) -> AIConfig:
+    """
+    Create and configure AI settings
+
+    Args:
+        **kwargs: Configuration options including API keys, model settings, etc.
+
+    Returns:
+        AIConfig instance
+
+    Example:
+        config = configure(
+            openai_api_key="your-key",
+            model="gpt-4",
+            temperature=0.7
+        )
+    """
+    return AIConfig(**kwargs)
+
+
+def agent(runner: str = "simple", memory: Optional[Memory] = None, config: Optional[AIConfig] = None, **kwargs) -> Agent:
+    """
+    Create an agent instance with the specified runner
+
+    Args:
+        runner: Agent runner type ("simple")
+        memory: Optional memory instance for context
+        config: Optional AIConfig instance for configuration
+        **kwargs: Additional configuration for the runner
+
+    Returns:
+        Agent instance
+
+    Example:
+        # Simple usage
+        chat = agent()
+
+        # With configuration
+        config = configure(openai_api_key="your-key")
+        chat = agent(runner="simple", config=config)
+
+        # With memory
+        mem = memory(provider="inmemory", user_id="user123")
+        chat = agent(runner="simple", memory=mem)
+    """
+    # Merge config if provided
+    if config:
+        kwargs.update(config.to_dict())
+
+    return Agent(runner=runner, memory=memory, **kwargs)

robyn/argument_parser.py

@@ -0,0 +1,129 @@
+import argparse
+import os
+
+
+class Config:
+    def __init__(self) -> None:
+        parser = argparse.ArgumentParser(description="Robyn, a fast async web framework with a rust runtime.")
+        self.parser = parser
+        parser.add_argument(
+            "--processes",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the number of processes. [Default: 1]",
+        )
+        parser.add_argument(
+            "--workers",
+            type=int,
+            default=None,
+            required=False,
+            help="Choose the number of workers. [Default: 1]",
+        )
+        parser.add_argument(
+            "--dev",
+            dest="dev",
+            action="store_true",
+            default=None,
+            help="Development mode. It restarts the server based on file changes.",
+        )
+        parser.add_argument(
+            "--log-level",
+            dest="log_level",
+            default=None,
+            help="Set the log level name",
+        )
+        parser.add_argument(
+            "--create",
+            action="store_true",
+            default=False,
+            help="Create a new project template.",
+        )
+        parser.add_argument(
+            "--docs",
+            action="store_true",
+            default=False,
+            help="Open the Robyn documentation.",
+        )
+        parser.add_argument(
+            "--open-browser",
+            action="store_true",
+            default=False,
+            help="Open the browser on successful start.",
+        )
+        parser.add_argument(
+            "--version",
+            action="store_true",
+            default=False,
+            help="Show the Robyn version.",
+        )
+        parser.add_argument(
+            "--compile-rust-path",
+            dest="compile_rust_path",
+            default=None,
+            help="Compile rust files in the given path.",
+        )
+
+        parser.add_argument(
+            "--create-rust-file",
+            dest="create_rust_file",
+            default=None,
+            help="Create a rust file with the given name.",
+        )
+        parser.add_argument(
+            "--disable-openapi",
+            dest="disable_openapi",
+            action="store_true",
+            default=False,
+            help="Disable the OpenAPI documentation.",
+        )
+        parser.add_argument(
+            "--fast",
+            dest="fast",
+            action="store_true",
+            default=False,
+            help="Fast mode. It sets the optimal values for processes, workers and log level. However, you can override them.",
+        )
+
+        args, unknown_args = parser.parse_known_args()
+        self.fast = args.fast
+        self.dev = args.dev
+        self.processes = args.processes
+        self.workers = args.workers
+        self.create = args.create
+        self.docs = args.docs
+        self.open_browser = args.open_browser
+        self.version = args.version
+        self.compile_rust_path = args.compile_rust_path
+        self.create_rust_file = args.create_rust_file
+        self.file_path = None
+        self.disable_openapi = args.disable_openapi
+        self.log_level = args.log_level
+
+        if self.fast:
+            # doing this here before every other check
+            # so that processes, workers and log_level can be overridden
+            cpu_count: int = os.cpu_count() or 1
+            self.processes = self.processes or ((cpu_count * 2) + 1) or 1
+            self.workers = self.workers or 2
+            self.log_level = self.log_level or "WARNING"
+
+        self.processes = self.processes or 1
+        self.workers = self.workers or 1
+
+        # find something that ends with .py in unknown_args
+        for arg in unknown_args:
+            if arg.endswith(".py"):
+                self.file_path = arg
+                break
+
+        if self.fast and self.dev:
+            raise Exception("--fast and --dev shouldn't be used together")
+
+        if self.dev and (self.processes != 1 or self.workers != 1):
+            raise Exception("--processes and --workers shouldn't be used with --dev")
+
+        if self.dev and self.log_level is None:
+            self.log_level = "DEBUG"
+        elif self.log_level is None:
+            self.log_level = "INFO"

robyn/authentication.py

@@ -0,0 +1,96 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from robyn.robyn import Headers, Identity, Request, Response
+from robyn.status_codes import HTTP_401_UNAUTHORIZED
+
+
+class AuthenticationNotConfiguredError(Exception):
+    """
+    This exception is raised when the authentication is not configured.
+    """
+
+    def __str__(self):
+        return "Authentication is not configured. Use app.configure_authentication() to configure it."
+
+
+class TokenGetter(ABC):
+    @property
+    def scheme(self) -> str:
+        """
+        Gets the scheme of the token.
+        :return: The scheme of the token.
+        """
+        return self.__class__.__name__
+
+    @classmethod
+    @abstractmethod
+    def get_token(cls, request: Request) -> Optional[str]:
+        """
+        Gets the token from the request.
+        This method should not decode the token. Decoding is the role of the authentication handler.
+        :param request: The request object.
+        :return: The encoded token.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    @abstractmethod
+    def set_token(cls, request: Request, token: str):
+        """
+        Sets the token in the request.
+        This method should not encode the token. Encoding is the role of the authentication handler.
+        :param request: The request object.
+        :param token: The encoded token.
+        """
+        raise NotImplementedError()
+
+
+class AuthenticationHandler(ABC):
+    def __init__(self, token_getter: TokenGetter):
+        """
+        Creates a new instance of the AuthenticationHandler class.
+        This class is an abstract class used to authenticate a user.
+        :param token_getter: The token getter used to get the token from the request.
+        """
+        self.token_getter = token_getter
+
+    @property
+    def unauthorized_response(self) -> Response:
+        return Response(
+            headers=Headers({"WWW-Authenticate": self.token_getter.scheme}),
+            description="Unauthorized",
+            status_code=HTTP_401_UNAUTHORIZED,
+        )
+
+    @abstractmethod
+    def authenticate(self, request: Request) -> Optional[Identity]:
+        """
+        Authenticates the user.
+        :param request: The request object.
+        :return: The identity of the user.
+        """
+        raise NotImplementedError()
+
+
+class BearerGetter(TokenGetter):
+    """
+    This class is used to get the token from the Authorization header.
+    The scheme of the header must be Bearer.
+    """
+
+    @classmethod
+    def get_token(cls, request: Request) -> Optional[str]:
+        if request.headers.contains("authorization"):
+            authorization_header = request.headers.get("authorization")
+        else:
+            authorization_header = None
+
+        if not authorization_header or not authorization_header.startswith("Bearer "):
+            return None
+
+        return authorization_header[7:]  # Remove the "Bearer " prefix
+
+    @classmethod
+    def set_token(cls, request: Request, token: str):
+        request.headers["Authorization"] = f"Bearer {token}"

robyn/cli.py

@@ -0,0 +1,136 @@
+import os
+import shutil
+import subprocess
+import sys
+import webbrowser
+from pathlib import Path
+from typing import Optional
+
+from InquirerPy.base.control import Choice
+from InquirerPy.resolver import prompt
+
+from robyn.env_populator import load_vars
+from robyn.robyn import get_version
+
+from .argument_parser import Config
+from .reloader import create_rust_file, setup_reloader
+
+SCAFFOLD_DIR = Path(__file__).parent / "scaffold"
+CURRENT_WORKING_DIR = Path.cwd()
+
+
+def create_robyn_app():
+    questions = [
+        {
+            "type": "input",
+            "message": "Directory Path:",
+            "name": "directory",
+        },
+        {
+            "type": "list",
+            "message": "Need Docker? (Y/N)",
+            "choices": [
+                Choice("Y", name="Y"),
+                Choice("N", name="N"),
+            ],
+            "default": Choice("N", name="N"),
+            "name": "docker",
+        },
+        {
+            "type": "list",
+            "message": "Please select project type (Mongo/Postgres/Sqlalchemy/Prisma): ",
+            "choices": [
+                Choice("no-db", name="No DB"),
+                Choice("sqlite", name="Sqlite"),
+                Choice("postgres", name="Postgres"),
+                Choice("mongo", name="MongoDB"),
+                Choice("sqlalchemy", name="SqlAlchemy"),
+                Choice("prisma", name="Prisma"),
+                Choice("sqlmodel", name="SQLModel"),
+            ],
+            "default": Choice("no-db", name="No DB"),
+            "name": "project_type",
+        },
+    ]
+    result = prompt(questions=questions)
+    project_dir_path = Path(str(result["directory"])).resolve()
+    docker = result["docker"]
+    project_type = str(result["project_type"])
+
+    final_project_dir_path = (CURRENT_WORKING_DIR / project_dir_path).resolve()
+
+    print(f"Creating a new Robyn project '{final_project_dir_path}'...")
+
+    # Create a new directory for the project
+    os.makedirs(final_project_dir_path, exist_ok=True)
+
+    selected_project_template = (SCAFFOLD_DIR / Path(project_type)).resolve()
+    shutil.copytree(str(selected_project_template), str(final_project_dir_path), dirs_exist_ok=True)
+
+    # If docker is not needed, delete the docker file
+    if docker == "N":
+        os.remove(f"{final_project_dir_path}/Dockerfile")
+
+    print(f"New Robyn project created in '{final_project_dir_path}' ")
+
+
+def docs():
+    print("Opening Robyn documentation... | Offline docs coming soon!")
+    webbrowser.open("https://robyn.tech")
+
+
+def start_dev_server(config: Config, file_path: Optional[str] = None):
+    if file_path is None:
+        return
+
+    absolute_file_path = (Path.cwd() / file_path).resolve()
+    directory_path = absolute_file_path.parent
+
+    if config.dev and not os.environ.get("IS_RELOADER_RUNNING", False):
+        setup_reloader(str(directory_path), str(absolute_file_path))
+        return
+
+
+def start_app_normally(config: Config):
+    command = [sys.executable]
+
+    for arg in sys.argv[1:]:
+        command.append(arg)
+
+    # Run the subprocess
+    subprocess.run(command, start_new_session=False)
+
+
+def run():
+    config = Config()
+
+    if not config.file_path:
+        config.file_path = f"{os.getcwd()}/{__name__}"
+
+    load_vars(project_root=os.path.dirname(os.path.abspath(config.file_path)))
+    os.environ["ROBYN_CLI"] = "True"
+
+    if config.dev is None:
+        config.dev = os.getenv("ROBYN_DEV_MODE", False) == "True"
+
+    if config.create:
+        create_robyn_app()
+
+    elif file_name := config.create_rust_file:
+        create_rust_file(file_name)
+
+    elif config.version:
+        print(get_version())
+
+    elif config.docs:
+        docs()
+
+    elif config.dev:
+        print("Starting dev server...")
+        start_dev_server(config, config.file_path)
+    else:
+        try:
+            start_app_normally(config)
+        except KeyboardInterrupt:
+            # for the crash happening upon pressing Ctrl + C
+            pass