rakam-eval-sdk 0.1.16__tar.gz → 0.1.16rc1__tar.gz

{rakam_eval_sdk-0.1.16 → rakam_eval_sdk-0.1.16rc1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.3
 Name: rakam-eval-sdk
-Version: 0.1.16
+Version: 0.1.16rc1
 Summary: Evaluation Framework SDK
 Author: Mohamed Bachar Touil
 License: MIT
+Requires-Dist: psutil>=7.2.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: requests
 Requires-Dist: typer>=0.20.1

{rakam_eval_sdk-0.1.16 → rakam_eval_sdk-0.1.16rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "rakam-eval-sdk"
-version = "0.1.16"
+version = "0.1.16rc1"
 description = "Evaluation Framework SDK"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -13,6 +13,7 @@ authors = [
     { name = "Mohamed Bachar Touil" }
 ]
 dependencies = [
+    "psutil>=7.2.1",
     "pydantic>=2.10.6",
     "requests",
     "typer>=0.20.1",
@@ -40,4 +41,4 @@ publish-url = "https://test.pypi.org/legacy/"
 explicit = true
 
 [project.scripts]
-mycli = "rakam_eval_sdk.cli:main"
+rakam_eval = "rakam_eval_sdk.cli:main"

rakam_eval_sdk-0.1.16rc1/src/rakam_eval_sdk/cli.py

@@ -0,0 +1,119 @@
+# cli.py
+from pathlib import Path
+
+import typer
+
+from rakam_eval_sdk.utils.decorator_utils import find_decorated_functions, load_module_from_path
+from rakam_eval_sdk.decorators import eval_run
+app = typer.Typer(help="CLI tools for evaluation utilities")
+
+
+@app.command()
+def find_eval_run_by_name(
+    directory: Path = typer.Argument(
+        Path("./eval"),
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan (default: ./eval)",
+    ),
+    recursive: bool = typer.Option(
+        False,
+        "--recursive",
+        "-r",
+        help="Recursively search for Python files",
+    ),
+):
+    """
+    Find functions decorated with @track.
+    """
+    TARGET_DECORATOR = eval_run.__name__
+    files = (
+        directory.rglob("*.py")
+        if recursive
+        else directory.glob("*.py")
+    )
+
+    found = False
+
+    for file in sorted(files):
+        functions = find_decorated_functions(file, TARGET_DECORATOR)
+        for fn in functions:
+            found = True
+            typer.echo(f"{file}:{fn}")
+
+    if not found:
+        typer.echo(f"No @{TARGET_DECORATOR} functions found.")
+
+
+@app.command("run")
+def run_eval_runs(
+    directory: Path = typer.Argument(
+        Path("./eval"),
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan (default: ./eval)",
+    ),
+    recursive: bool = typer.Option(
+        False,
+        "-r",
+        "--recursive",
+        help="Recursively search for Python files",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Only list functions without executing them",
+    ),
+):
+    """
+    Find and execute all functions decorated with @eval_run.
+    """
+    files = (
+        directory.rglob("*.py")
+        if recursive
+        else directory.glob("*.py")
+    )
+    TARGET_DECORATOR = eval_run.__name__
+
+    executed_any = False
+
+    for file in sorted(files):
+        functions = find_decorated_functions(file, TARGET_DECORATOR)
+        if not functions:
+            continue
+
+        typer.echo(f"\n📄 {file}")
+
+        module = None
+        if not dry_run:
+            try:
+                module = load_module_from_path(file)
+            except Exception as e:
+                typer.echo(f"  ❌ Failed to import module: {e}")
+                continue
+
+        for fn_name in functions:
+            typer.echo(f"  ▶ {fn_name}")
+
+            if dry_run:
+                continue
+
+            try:
+                func = getattr(module, fn_name)
+                func()  # <-- actual execution
+                executed_any = True
+            except Exception as e:
+                typer.echo(f"    ❌ Execution failed: {e}")
+
+    if not executed_any and not dry_run:
+        typer.echo("\nNo @eval_run functions executed.")
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

rakam_eval_sdk-0.1.16rc1/src/rakam_eval_sdk/decorators.py

@@ -0,0 +1,44 @@
+
+import time
+import os
+import psutil
+import functools
+
+
+def eval_run(*dargs, **dkwargs):
+    def wrapper(func):
+        @functools.wraps(func)
+        def inner(*args, **kwargs):
+            process = psutil.Process(os.getpid())
+
+            # Start metrics
+            start_time = time.perf_counter()
+            start_cpu = process.cpu_times()
+            start_mem = process.memory_info().rss
+
+            try:
+                result = func(*args, **kwargs)
+                return result
+            finally:
+                # End metrics
+                end_time = time.perf_counter()
+                end_cpu = process.cpu_times()
+                end_mem = process.memory_info().rss
+
+                elapsed = end_time - start_time
+                cpu_used = (
+                    (end_cpu.user + end_cpu.system)
+                    - (start_cpu.user + start_cpu.system)
+                )
+                mem_diff_mb = (end_mem - start_mem) / (1024 * 1024)
+
+                print(
+                    f"[eval_run] {func.__module__}.{func.__name__} | "
+                    f"time={elapsed:.4f}s | "
+                    f"cpu={cpu_used:.4f}s | "
+                    f"mem_delta={mem_diff_mb:.2f}MB"
+                )
+
+        return inner
+
+    return wrapper

rakam_eval_sdk-0.1.16rc1/src/rakam_eval_sdk/utils/decorator_utils.py

@@ -0,0 +1,69 @@
+import ast
+import importlib
+import importlib.util
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Callable, Iterable, List, Tuple
+
+
+class DecoratedFunctionVisitor(ast.NodeVisitor):
+    def __init__(self, decorator_name: str):
+        self.decorator_name = decorator_name
+        self.results: List[str] = []
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        for deco in node.decorator_list:
+            if self._matches(deco):
+                self.results.append(node.name)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        for deco in node.decorator_list:
+            if self._matches(deco):
+                self.results.append(node.name)
+        self.generic_visit(node)
+
+    def _matches(self, deco: ast.expr) -> bool:
+        # @deco
+        if isinstance(deco, ast.Name):
+            return deco.id == self.decorator_name
+
+        # @module.deco
+        if isinstance(deco, ast.Attribute):
+            return deco.attr == self.decorator_name
+
+        # @deco(...)
+        if isinstance(deco, ast.Call):
+            return self._matches(deco.func)
+
+        return False
+
+
+def find_decorated_functions(
+    file_path: Path,
+    decorator_name: str,
+) -> List[str]:
+    tree = ast.parse(file_path.read_text(encoding="utf-8"))
+    visitor = DecoratedFunctionVisitor(decorator_name)
+    visitor.visit(tree)
+    return visitor.results
+
+
+def load_module_from_path(file_path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(file_path.stem, file_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot import {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+
+
+
+def get_function(module: ModuleType, function_name: str) -> Callable:
+    func = getattr(module, function_name, None)
+    if func is None:
+        raise AttributeError(f"{function_name} not found in {module.__name__}")
+    return func

rakam_eval_sdk-0.1.16/src/rakam_eval_sdk/cli.py

@@ -1,17 +0,0 @@
-# cli.py
-import typer
-from pathlib import Path
-
-app = typer.Typer()
-
-
-@app.command()
-def read(file: Path):
-    """Read a Python file"""
-    if file.suffix != ".py":
-        raise typer.BadParameter("Must be a .py file")
-    typer.echo(file.read_text())
-
-
-def main():
-    app()