aiauto-client 0.1.0__tar.gz → 0.1.1__tar.gz

{aiauto_client-0.1.0 → aiauto_client-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiauto-client
-Version: 0.1.0
+Version: 0.1.1
 Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
 Author-email: AIAuto Team <ainode@zeroone.ai>
 Project-URL: Homepage, https://aiauto.cloude.ainode.ai
@@ -21,9 +21,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: optuna>=3.0.0
-Requires-Dist: grpcio>=1.50.0
-Requires-Dist: grpcio-tools>=1.50.0
-Requires-Dist: protobuf>=4.0.0
+Requires-Dist: requests>=2.25.0
 
 # AIAuto - Hyperparameter Optimization Client Library
 
@@ -31,44 +29,80 @@ AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템
 사용자 python lib <-> Next.js 서버 사이 gRPC 통신 담당
 
 ## lib build
-- pypi build, upload 종속성 다운로드 `pip install build twine`
-- build lib `python -m build --wheel --sdist`
-  - `aiauto-0.1.0.whl` 생성
-  - `aiauto-0.1.0.tar.gz` 생성
-  - `aiauto.egg-info` 생성
-- `twine upload --repository testpypi dist/*`
+- pypi build, upload 종속성 다운로드 `uv add --dev twine`
+- build lib `uv build`
+  - `aiauto_client-0.1.1-py3-none-any.whl` 생성
+  - `aiauto_client-0.1.1.tar.gz` 생성
+  - `aiauto_client.egg-info` 생성
+- `~/.pypirc` 파일에 설정 확인
+- `twine upload --repository aiauto-client dist/*`
 - `twine upload dist/*`
   - upload 시 pypi token 을 입력하라고 나옴, pypi 로그인 계정 설정가면 있다 
 
 ## 설치
-- `pip install aiauto`
+- `uv add aiauto-client`
 
 ## 빠른 시작
+
+### Study 생성 및 Ask/Tell 패턴
 ```python
 import aiauto
 
-# 컨트롤러 초기화
-ac = aiauto.AIAutoController()
+# StudyWrapper 생성 (JWT 토큰 필요)
+studyWrapper = aiauto.create_study(
+    study_name='my_optimization',
+    token='your_jwt_token',
+    direction='maximize'
+)
+
+# 실제 optuna.Study 객체 획득 (로컬에서 ask/tell 가능)
+study = studyWrapper.get_study()
+
+# Ask/Tell 패턴으로 최적화
+trial = study.ask()
+params = trial.params
+
+# 사용자 모델 학습
+accuracy = train_model(params)
+
+# 결과 보고
+study.tell(trial, accuracy)
+```
+
+### 분산 최적화 (Pod 실행)
+```python
+import aiauto
 
-# Objective 함수 정의
 def objective(trial):
     tc = aiauto.TrialController(trial)
     
     # 하이퍼파라미터 샘플링
     lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+    batch_size = trial.suggest_int('batch_size', 16, 128)
     
-    # 모델 학습 및 평가 로직
-    # ...
-    tc.log(f'full dataset: train {len(dataset)}, test {len(dataset_test)}, batch_size {batch_size}')
+    # 모델 학습 로직
+    accuracy = train_model(lr, batch_size)
+    
+    tc.log(f'lr: {lr}, batch_size: {batch_size}, accuracy: {accuracy}')
     
     return accuracy
 
-# Study 생성 및 최적화 실행
-study = optuna.create_study(
-    study_name='my_optimization',
-    storage=ac.get_storage(),
+# StudyWrapper 생성
+studyWrapper = aiauto.create_study(
+    study_name='distributed_optimization',
+    token='your_jwt_token',
     direction='maximize'
 )
 
-study.optimize(objective, n_trials=100)
+# 분산 최적화 실행 (Kubernetes Pod에서 실행)
+studyWrapper.optimize(
+    objective=objective,
+    n_trials=100,
+    parallelism=4,
+    requirements_list=['torch==2.0.0', 'torchvision==0.15.0']
+)
+
+# 실시간 상태 모니터링
+status = studyWrapper.get_status()
+print(f"Active: {status['count_active']}, Completed: {status['count_completed']}")
 ```

aiauto_client-0.1.1/README.md

@@ -0,0 +1,83 @@
+# AIAuto - Hyperparameter Optimization Client Library
+
+AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템을 위한 클라이언트 라이브러리입니다.
+사용자 python lib <-> Next.js 서버 사이 gRPC 통신 담당
+
+## lib build
+- pypi build, upload 종속성 다운로드 `uv add --dev twine`
+- build lib `uv build`
+  - `aiauto_client-0.1.1-py3-none-any.whl` 생성
+  - `aiauto_client-0.1.1.tar.gz` 생성
+  - `aiauto_client.egg-info` 생성
+- `~/.pypirc` 파일에 설정 확인
+- `twine upload --repository aiauto-client dist/*`
+- `twine upload dist/*`
+  - upload 시 pypi token 을 입력하라고 나옴, pypi 로그인 계정 설정가면 있다 
+
+## 설치
+- `uv add aiauto-client`
+
+## 빠른 시작
+
+### Study 생성 및 Ask/Tell 패턴
+```python
+import aiauto
+
+# StudyWrapper 생성 (JWT 토큰 필요)
+studyWrapper = aiauto.create_study(
+    study_name='my_optimization',
+    token='your_jwt_token',
+    direction='maximize'
+)
+
+# 실제 optuna.Study 객체 획득 (로컬에서 ask/tell 가능)
+study = studyWrapper.get_study()
+
+# Ask/Tell 패턴으로 최적화
+trial = study.ask()
+params = trial.params
+
+# 사용자 모델 학습
+accuracy = train_model(params)
+
+# 결과 보고
+study.tell(trial, accuracy)
+```
+
+### 분산 최적화 (Pod 실행)
+```python
+import aiauto
+
+def objective(trial):
+    tc = aiauto.TrialController(trial)
+    
+    # 하이퍼파라미터 샘플링
+    lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+    batch_size = trial.suggest_int('batch_size', 16, 128)
+    
+    # 모델 학습 로직
+    accuracy = train_model(lr, batch_size)
+    
+    tc.log(f'lr: {lr}, batch_size: {batch_size}, accuracy: {accuracy}')
+    
+    return accuracy
+
+# StudyWrapper 생성
+studyWrapper = aiauto.create_study(
+    study_name='distributed_optimization',
+    token='your_jwt_token',
+    direction='maximize'
+)
+
+# 분산 최적화 실행 (Kubernetes Pod에서 실행)
+studyWrapper.optimize(
+    objective=objective,
+    n_trials=100,
+    parallelism=4,
+    requirements_list=['torch==2.0.0', 'torchvision==0.15.0']
+)
+
+# 실시간 상태 모니터링
+status = studyWrapper.get_status()
+print(f"Active: {status['count_active']}, Completed: {status['count_completed']}")
+```

{aiauto_client-0.1.0 → aiauto_client-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiauto-client"
-version = "0.1.0"
+version = "0.1.1"
 description = "AI Auto HPO (Hyperparameter Optimization) Client Library"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -27,9 +27,7 @@ classifiers = [
 ]
 dependencies = [
     "optuna>=3.0.0",
-    "grpcio>=1.50.0",
-    "grpcio-tools>=1.50.0",
-    "protobuf>=4.0.0",
+    "requests>=2.25.0",
 ]
 
 [project.urls]
@@ -58,3 +56,9 @@ testpaths = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "twine>=6.1.0",
+]

aiauto_client-0.1.1/src/aiauto/__init__.py

@@ -0,0 +1,16 @@
+from .core import AIAutoController, TrialController, CallbackTopNArtifact, StudyWrapper
+from .api import create_study
+from ._config import AIAUTO_API_TARGET
+from .constants import RUNTIME_IMAGES
+
+__version__ = "0.1.0"
+
+__all__ = [
+    'AIAutoController',
+    'TrialController', 
+    'CallbackTopNArtifact',
+    'StudyWrapper',
+    'create_study',
+    'AIAUTO_API_TARGET',
+    'RUNTIME_IMAGES',
+]

aiauto_client-0.1.1/src/aiauto/_config.py

@@ -0,0 +1,3 @@
+# For Connect RPC over HTTP
+# This will be converted to https://api.aiauto.cloud.ainode.ai in production
+AIAUTO_API_TARGET = "api.aiauto.cloud.ainode.ai:443"

aiauto_client-0.1.1/src/aiauto/api.py

@@ -0,0 +1,46 @@
+from typing import Optional, List, Union
+from .serializer import object_to_json
+from .core import StudyWrapper, AIAutoController
+
+
+def create_study(
+    study_name: str,
+    token: str,
+    direction: Optional[str] = None,
+    directions: Optional[List[str]] = None,
+    sampler: Union[object, dict, None] = None,
+    pruner: Union[object, dict, None] = None
+) -> StudyWrapper:
+    if not direction and not directions:
+        raise ValueError("Either 'direction' or 'directions' must be specified")
+
+    if direction and directions:
+        raise ValueError("Cannot specify both 'direction' and 'directions'")
+
+    try:
+        # Initialize controller (which ensures workspace)
+        controller = AIAutoController(token)
+        
+        # Prepare request data for CreateStudy
+        request_data = {
+            "spec": {
+                "studyName": study_name,
+                "direction": direction or "",
+                "directions": directions or [],
+                "samplerJson": object_to_json(sampler),
+                "prunerJson": object_to_json(pruner)
+            }
+        }
+        
+        # Call CreateStudy RPC
+        response = controller.client.call_rpc("CreateStudy", request_data)
+        
+        # Return StudyWrapper
+        return StudyWrapper(
+            study_name=response.get("studyName", study_name),
+            storage=controller.storage,
+            controller=controller
+        )
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to create study: {e}") from e

aiauto_client-0.1.1/src/aiauto/constants.py

@@ -0,0 +1,28 @@
+# Runtime image constants for AIAuto
+# These images are pre-tested and guaranteed to work with AIAuto
+
+# Available runtime images
+RUNTIME_IMAGES = [
+    # CPU Images
+    "ghcr.io/astral-sh/uv:python3.8-bookworm-slim",
+    "ghcr.io/astral-sh/uv:python3.9-bookworm-slim",
+    "ghcr.io/astral-sh/uv:python3.10-bookworm-slim",
+    "ghcr.io/astral-sh/uv:python3.11-bookworm-slim",
+    "ghcr.io/astral-sh/uv:python3.12-bookworm-slim",
+    
+    # GPU Images (PyTorch)
+    "pytorch/pytorch:2.1.0-cuda11.8-cudnn8-runtime",
+    "pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime",
+    "pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime",
+    
+    # GPU Images (TensorFlow)
+    "tensorflow/tensorflow:2.15.0-gpu",
+    "tensorflow/tensorflow:2.15.0-gpu-jupyter",
+    
+    # JAX Images
+    "nvcr.io/nvidia/jax:23.10-py3",
+    "nvcr.io/nvidia/jax:24.04-py3",
+    
+    # Custom/Legacy images
+    "ghcr.io/01ai/zipline:latest",  # Custom zipline trading library
+]

aiauto_client-0.1.1/src/aiauto/core.py

@@ -0,0 +1,197 @@
+from os import makedirs
+import tempfile
+from typing import Union, Optional, List, Dict, Callable
+import optuna
+from .http_client import ConnectRPCClient
+from .serializer import serialize, build_requirements
+from ._config import AIAUTO_API_TARGET
+
+
+class AIAutoController:
+    _instances = {}
+
+    def __new__(cls, token: str):
+        if token not in cls._instances:
+            cls._instances[token] = super().__new__(cls)
+        return cls._instances[token]
+
+    def __init__(self, token: str):
+        if hasattr(self, 'token') and self.token == token:
+            return
+
+        self.token = token
+        self.client = ConnectRPCClient(token)
+
+        # EnsureWorkspace 호출해서 journal_grpc_storage_proxy_host_external 받아와서 storage 초기화
+        try:
+            response = self.client.call_rpc("EnsureWorkspace", {})
+            
+            # 받아온 journal_grpc_storage_proxy_host_external로 storage 초기화
+            host_external = response.get('journalGrpcStorageProxyHostExternal', '')
+            if not host_external:
+                raise RuntimeError("No storage host returned from EnsureWorkspace")
+            
+            host, port = host_external.split(':')
+            self.storage = optuna.storages.GrpcStorageProxy(host=host, port=int(port))
+            
+            # Store the internal host for CRD usage (if needed later)
+            self.storage_host_internal = response.get('journalGrpcStorageProxyHostInternal', '')
+            self.dashboard_url = response.get('dashboardUrl', '')
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize workspace: {e}") from e
+
+        # artifact storage
+        makedirs('./artifacts', exist_ok=True)
+        self.artifact_store = optuna.artifacts.FileSystemArtifactStore('./artifacts')
+        self.tmp_dir = tempfile.mkdtemp(prefix=f'ai_auto_tmp_')
+
+    def get_storage(self):
+        return self.storage
+
+    def get_artifact_store(self) -> Union[
+        optuna.artifacts.FileSystemArtifactStore,
+        optuna.artifacts.Boto3ArtifactStore,
+        optuna.artifacts.GCSArtifactStore,
+    ]:
+        return self.artifact_store
+
+    def get_artifact_tmp_dir(self):
+        return self.tmp_dir
+
+
+class TrialController:
+    def __init__(self, trial: optuna.trial.Trial):
+        self.trial = trial
+        self.logger = optuna.logging.get_logger("optuna")
+        self.logs = []
+
+    def get_trial(self) -> optuna.trial.Trial:
+        return self.trial
+
+    def log(self, value: str):
+        # optuna dashboard 에 log 를 확인하는 기능이 없어서 user_attribute 에 log를 확인할 수 있게 추가
+        self.logs.append(value)
+        self.trial.set_user_attr('logs', ' '.join([f"[{i+1:05d}] {log}" for i, log in enumerate(self.logs)]))
+        # 실제 log 를 trial_number 랑 같이 확인할 수 있게
+        self.logger.info(f'\ntrial_number: {self.trial.number}, {value}')
+
+
+# 용량 제한으로 상위 N개의 trial artifact 만 유지
+class CallbackTopNArtifact:
+    def __init__(
+        self,
+        artifact_store: Union[
+            optuna.artifacts.FileSystemArtifactStore,
+            optuna.artifacts.Boto3ArtifactStore,
+            optuna.artifacts.GCSArtifactStore,
+        ],
+        artifact_attr_name: str = 'artifact_id',
+        n_keep: int = 5,
+    ):
+        self.artifact_store = artifact_store
+        self.check_attr_name = artifact_attr_name
+        self.n_keep = n_keep
+
+    def __call__(self, study: optuna.study.Study, trial: optuna.trial.FrozenTrial):
+        # COMPLETE 상태이고 artifact를 가진 trial들만 정렬
+        finished_with_artifacts = [
+            t for t in study.trials
+            if t.state == optuna.trial.TrialState.COMPLETE and self.check_attr_name in t.user_attrs
+        ]
+
+        # 방향에 따라 정렬 (maximize면 내림차순, minimize면 오름차순)
+        reverse_sort = study.direction == optuna.study.StudyDirection.MAXIMIZE
+        finished_with_artifacts.sort(key=lambda t: t.value, reverse=reverse_sort)
+
+        # 상위 n_keep개 초과하는 trial들의 artifact 삭제
+        for old_trial in finished_with_artifacts[self.n_keep:]:
+            artifact_id = old_trial.user_attrs.get(self.check_attr_name)
+            if artifact_id:
+                try:
+                    self.artifact_store.remove(artifact_id)
+                    # user_attr에서도 제거
+                    study._storage.set_trial_user_attr(old_trial._trial_id, self.check_attr_name, None)
+                except Exception as e:
+                    print(f"Warning: Failed to remove artifact {artifact_id}: {e}")
+
+
+class StudyWrapper:
+    def __init__(self, study_name: str, storage, controller: AIAutoController):
+        self.study_name = study_name
+        self._storage = storage
+        self._controller = controller
+        self._study = None
+
+    def get_study(self) -> optuna.Study:
+        if self._study is None:
+            try:
+                self._study = optuna.create_study(
+                    study_name=self.study_name,
+                    storage=self._storage,
+                    load_if_exists=True
+                )
+            except Exception as e:
+                raise RuntimeError("Study not ready. Call get_status() and wait for phase=Ready.") from e
+        return self._study
+
+    def optimize(
+        self,
+        objective: Callable,
+        n_trials: int,
+        parallelism: int,
+        requirements_file: Optional[str] = None,
+        requirements_list: Optional[List[str]] = None,
+        resources_requests: Optional[Dict[str, str]] = None,
+        resources_limits: Optional[Dict[str, str]] = None,
+        runtime_image: Optional[str] = None,
+        use_gpu: bool = False
+    ) -> None:
+        try:
+            request_data = {
+                "objective": {
+                    "sourceCode": serialize(objective),
+                    "requirementsTxt": build_requirements(requirements_file, requirements_list)
+                },
+                "batch": {
+                    "studyName": self.study_name,
+                    "nTrials": n_trials,
+                    "parallelism": parallelism,
+                    "runtimeImage": runtime_image or "",
+                    "resourcesRequests": resources_requests or {},
+                    "resourcesLimits": resources_limits or {},
+                    "useGpu": use_gpu
+                }
+            }
+            
+            self._controller.client.call_rpc("Optimize", request_data)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to start optimization: {e}") from e
+
+    def get_status(self) -> dict:
+        try:
+            response = self._controller.client.call_rpc(
+                "GetStatus", 
+                {"studyName": self.study_name}
+            )
+            
+            # Convert camelCase to snake_case for backward compatibility
+            return {
+                "study_name": response.get("studyName", ""),
+                "count_active": response.get("countActive", 0),
+                "count_succeeded": response.get("countSucceeded", 0),
+                "count_pruned": response.get("countPruned", 0),
+                "count_failed": response.get("countFailed", 0),
+                "count_total": response.get("countTotal", 0),
+                "count_completed": response.get("countCompleted", 0),
+                "dashboard_url": response.get("dashboardUrl", ""),
+                "last_error": response.get("lastError", ""),
+                "updated_at": response.get("updatedAt", "")
+            }
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to get status: {e}") from e
+
+    def __repr__(self) -> str:
+        return f"StudyWrapper(study_name='{self.study_name}', storage={self._storage})"

aiauto_client-0.1.1/src/aiauto/http_client.py

@@ -0,0 +1,50 @@
+"""HTTP client for Connect RPC communication with Next.js server."""
+import requests
+from typing import Dict, Any, Optional
+from ._config import AIAUTO_API_TARGET
+
+
+class ConnectRPCClient:
+    """Client for calling Connect RPC endpoints via HTTP/JSON."""
+    
+    def __init__(self, token: str, base_url: Optional[str] = None):
+        self.token = token
+        # Convert gRPC target to HTTP URL
+        if base_url:
+            self.base_url = base_url
+        else:
+            # AIAUTO_API_TARGET is like "api.aiauto.cloud.ainode.ai:443"
+            # Convert to "https://api.aiauto.cloud.ainode.ai"
+            host = AIAUTO_API_TARGET.split(':')[0]
+            self.base_url = f"https://{host}"
+        
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "Connect-Protocol-Version": "1"
+        }
+    
+    def call_rpc(self, method: str, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Call a Connect RPC method and return the response."""
+        url = f"{self.base_url}/api/aiauto.v1.AIAutoService/{method}"
+        
+        try:
+            response = requests.post(url, json=request_data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            # Connect RPC error format
+            if e.response and e.response.headers.get('content-type', '').startswith('application/json'):
+                error_data = e.response.json()
+                error_msg = error_data.get('message', str(e))
+                raise RuntimeError(f"RPC error: {error_msg}") from e
+            raise RuntimeError(f"HTTP error: {e}") from e
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(f"Request failed: {e}") from e
+
+
+def map_http_error(exc: Exception) -> Exception:
+    """Convert HTTP/Connect RPC errors to standard exceptions."""
+    # For now, just pass through the exception
+    # In the future, we can add more sophisticated error mapping
+    return exc

aiauto_client-0.1.1/src/aiauto/serializer.py

@@ -0,0 +1,55 @@
+import inspect
+import json
+from typing import Callable, Union, List, Optional
+
+
+def serialize(objective: Callable) -> str:
+    try:
+        return inspect.getsource(objective)
+    except Exception as e:
+        raise ValueError("objective는 모듈 최상위 def만 허용합니다(데코레이터/로컬/람다 불가)") from e
+
+
+def build_requirements(file_path: Optional[str] = None, reqs: Optional[List[str]] = None) -> str:
+    if file_path and reqs:
+        raise ValueError("requirements_file과 requirements_list는 동시에 지정할 수 없습니다")
+    
+    if file_path:
+        with open(file_path, 'r') as f:
+            return f.read()
+    elif reqs:
+        return "\n".join(reqs)
+    else:
+        return ""
+
+
+def object_to_json(obj: Union[object, dict, None]) -> str:
+    if obj is None:
+        return ""
+    
+    if isinstance(obj, dict):
+        return json.dumps(obj)
+    
+    cls = type(obj)
+    module_name = cls.__module__
+    class_name = cls.__name__
+    
+    if not module_name.startswith('optuna.'):
+        raise ValueError(f"optuna 코어 클래스만 지원합니다: {class_name}")
+    
+    sig = inspect.signature(cls)
+    kwargs = {}
+    
+    for param_name, param in sig.parameters.items():
+        if param_name == 'self':
+            continue
+        if hasattr(obj, param_name):
+            value = getattr(obj, param_name)
+            if param.default != value:
+                kwargs[param_name] = value
+    
+    return json.dumps({
+        "module": module_name,
+        "class": class_name,
+        "kwargs": kwargs
+    })

{aiauto_client-0.1.0 → aiauto_client-0.1.1}/src/aiauto_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiauto-client
-Version: 0.1.0
+Version: 0.1.1
 Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
 Author-email: AIAuto Team <ainode@zeroone.ai>
 Project-URL: Homepage, https://aiauto.cloude.ainode.ai
@@ -21,9 +21,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: optuna>=3.0.0
-Requires-Dist: grpcio>=1.50.0
-Requires-Dist: grpcio-tools>=1.50.0
-Requires-Dist: protobuf>=4.0.0
+Requires-Dist: requests>=2.25.0
 
 # AIAuto - Hyperparameter Optimization Client Library
 
@@ -31,44 +29,80 @@ AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템
 사용자 python lib <-> Next.js 서버 사이 gRPC 통신 담당
 
 ## lib build
-- pypi build, upload 종속성 다운로드 `pip install build twine`
-- build lib `python -m build --wheel --sdist`
-  - `aiauto-0.1.0.whl` 생성
-  - `aiauto-0.1.0.tar.gz` 생성
-  - `aiauto.egg-info` 생성
-- `twine upload --repository testpypi dist/*`
+- pypi build, upload 종속성 다운로드 `uv add --dev twine`
+- build lib `uv build`
+  - `aiauto_client-0.1.1-py3-none-any.whl` 생성
+  - `aiauto_client-0.1.1.tar.gz` 생성
+  - `aiauto_client.egg-info` 생성
+- `~/.pypirc` 파일에 설정 확인
+- `twine upload --repository aiauto-client dist/*`
 - `twine upload dist/*`
   - upload 시 pypi token 을 입력하라고 나옴, pypi 로그인 계정 설정가면 있다 
 
 ## 설치
-- `pip install aiauto`
+- `uv add aiauto-client`
 
 ## 빠른 시작
+
+### Study 생성 및 Ask/Tell 패턴
 ```python
 import aiauto
 
-# 컨트롤러 초기화
-ac = aiauto.AIAutoController()
+# StudyWrapper 생성 (JWT 토큰 필요)
+studyWrapper = aiauto.create_study(
+    study_name='my_optimization',
+    token='your_jwt_token',
+    direction='maximize'
+)
+
+# 실제 optuna.Study 객체 획득 (로컬에서 ask/tell 가능)
+study = studyWrapper.get_study()
+
+# Ask/Tell 패턴으로 최적화
+trial = study.ask()
+params = trial.params
+
+# 사용자 모델 학습
+accuracy = train_model(params)
+
+# 결과 보고
+study.tell(trial, accuracy)
+```
+
+### 분산 최적화 (Pod 실행)
+```python
+import aiauto
 
-# Objective 함수 정의
 def objective(trial):
     tc = aiauto.TrialController(trial)
     
     # 하이퍼파라미터 샘플링
     lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+    batch_size = trial.suggest_int('batch_size', 16, 128)
     
-    # 모델 학습 및 평가 로직
-    # ...
-    tc.log(f'full dataset: train {len(dataset)}, test {len(dataset_test)}, batch_size {batch_size}')
+    # 모델 학습 로직
+    accuracy = train_model(lr, batch_size)
+    
+    tc.log(f'lr: {lr}, batch_size: {batch_size}, accuracy: {accuracy}')
     
     return accuracy
 
-# Study 생성 및 최적화 실행
-study = optuna.create_study(
-    study_name='my_optimization',
-    storage=ac.get_storage(),
+# StudyWrapper 생성
+studyWrapper = aiauto.create_study(
+    study_name='distributed_optimization',
+    token='your_jwt_token',
     direction='maximize'
 )
 
-study.optimize(objective, n_trials=100)
+# 분산 최적화 실행 (Kubernetes Pod에서 실행)
+studyWrapper.optimize(
+    objective=objective,
+    n_trials=100,
+    parallelism=4,
+    requirements_list=['torch==2.0.0', 'torchvision==0.15.0']
+)
+
+# 실시간 상태 모니터링
+status = studyWrapper.get_status()
+print(f"Active: {status['count_active']}, Completed: {status['count_completed']}")
 ```

{aiauto_client-0.1.0 → aiauto_client-0.1.1}/src/aiauto_client.egg-info/SOURCES.txt

@@ -1,10 +1,15 @@
 README.md
 pyproject.toml
 src/aiauto/__init__.py
+src/aiauto/_config.py
+src/aiauto/api.py
+src/aiauto/constants.py
 src/aiauto/core.py
-src/aiauto/serialization.py
+src/aiauto/http_client.py
+src/aiauto/serializer.py
 src/aiauto_client.egg-info/PKG-INFO
 src/aiauto_client.egg-info/SOURCES.txt
 src/aiauto_client.egg-info/dependency_links.txt
 src/aiauto_client.egg-info/requires.txt
-src/aiauto_client.egg-info/top_level.txt
+src/aiauto_client.egg-info/top_level.txt
+tests/test_local_storage.py

aiauto_client-0.1.1/src/aiauto_client.egg-info/requires.txt

@@ -0,0 +1,2 @@
+optuna>=3.0.0
+requests>=2.25.0

aiauto_client-0.1.1/tests/test_local_storage.py

@@ -0,0 +1,59 @@
+import aiauto
+import optuna
+from unittest.mock import patch
+
+
+def objective(trial):
+    """간단한 이차함수 최적화 예제"""
+    # TrialController를 사용한 로깅
+    tc = aiauto.TrialController(trial)
+    tc.log("Starting simple optimization example")
+
+    # 하이퍼파라미터 샘플링
+    x = trial.suggest_float('x', -10, 10)
+    y = trial.suggest_float('y', -10, 10)
+
+    # 목적함수: (x-2)² + (y-5)² 최소화
+    result = (x - 2) ** 2 + (y - 5) ** 2
+
+    tc.log(f"x={x:.3f}, y={y:.3f}, result={result:.3f}")
+
+    return result
+
+
+def main():
+    print("🚀 AIAuto 소스코드 직렬화 로컬 테스트")
+
+    # AIAutoController의 storage를 InMemoryStorage로 패치
+    with patch.object(aiauto.AIAutoController, '__init__', lambda self: None):
+        controller = aiauto.AIAutoController()
+        # 로컬 테스트용 InMemoryStorage 설정
+        controller.storage = optuna.storages.InMemoryStorage()
+        controller.artifact_store = optuna.artifacts.FileSystemArtifactStore('./artifacts')
+
+        # 소스코드 직렬화 테스트
+        print("\n=== 소스코드 직렬화 테스트 ===")
+        study_wrapper = controller.create_study(
+            objective=objective,
+            study_name='local_test',
+            direction='minimize'
+        )
+
+        print("✅ StudyWrapper 생성 성공!")
+
+        # 최적화 실행
+        print("\n=== 최적화 실행 ===")
+        study_wrapper.optimize(n_trials=10)
+
+        # 결과 출력
+        print(f"\n🎉 최적화 완료!")
+        print(f"📊 Best value: {study_wrapper.best_value:.3f}")
+        print(f"🔧 Best params: {study_wrapper.best_params}")
+
+        # 이론적 최적해: x=2, y=5, result=0
+        print(f"💡 이론적 최적해: x=2, y=5, result=0")
+        print(f"📈 오차: {study_wrapper.best_value:.3f}")
+
+
+if __name__ == "__main__":
+    main()

aiauto_client-0.1.0/README.md

@@ -1,47 +0,0 @@
-# AIAuto - Hyperparameter Optimization Client Library
-
-AIAuto는 Kubernetes 기반의 분산 HPO(Hyperparameter Optimization) 시스템을 위한 클라이언트 라이브러리입니다.
-사용자 python lib <-> Next.js 서버 사이 gRPC 통신 담당
-
-## lib build
-- pypi build, upload 종속성 다운로드 `pip install build twine`
-- build lib `python -m build --wheel --sdist`
-  - `aiauto-0.1.0.whl` 생성
-  - `aiauto-0.1.0.tar.gz` 생성
-  - `aiauto.egg-info` 생성
-- `twine upload --repository testpypi dist/*`
-- `twine upload dist/*`
-  - upload 시 pypi token 을 입력하라고 나옴, pypi 로그인 계정 설정가면 있다 
-
-## 설치
-- `pip install aiauto`
-
-## 빠른 시작
-```python
-import aiauto
-
-# 컨트롤러 초기화
-ac = aiauto.AIAutoController()
-
-# Objective 함수 정의
-def objective(trial):
-    tc = aiauto.TrialController(trial)
-    
-    # 하이퍼파라미터 샘플링
-    lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
-    
-    # 모델 학습 및 평가 로직
-    # ...
-    tc.log(f'full dataset: train {len(dataset)}, test {len(dataset_test)}, batch_size {batch_size}')
-    
-    return accuracy
-
-# Study 생성 및 최적화 실행
-study = optuna.create_study(
-    study_name='my_optimization',
-    storage=ac.get_storage(),
-    direction='maximize'
-)
-
-study.optimize(objective, n_trials=100)
-```

aiauto_client-0.1.0/src/aiauto/__init__.py

@@ -1,50 +0,0 @@
-from .core import AIAutoController, TrialController, CallbackTopNArtifact, StudyWrapper
-from .serialization import SourceCodeSerializer, create_study_with_source_serialization
-
-__version__ = "0.1.0"
-
-__all__ = [
-    'AIAutoController',
-    'TrialController', 
-    'CallbackTopNArtifact',
-    'StudyWrapper',
-    'SourceCodeSerializer',
-    'create_study_with_source_serialization',
-]
-
-# Optuna 호환성을 위한 간편 함수
-def create_study(
-    objective=None,
-    study_name='aiauto_study', 
-    direction='minimize',
-    **kwargs
-):
-    """
-    Optuna 호환 create_study 함수
-    
-    사용법:
-        study = aiauto.create_study(
-            objective=my_objective,
-            study_name='my_study',
-            direction='maximize'
-        )
-        study.optimize(n_trials=100)
-    """
-    controller = AIAutoController()
-    
-    if objective is not None:
-        return controller.create_study_with_serialization(
-            objective=objective,
-            study_name=study_name,
-            direction=direction,
-            **kwargs
-        )
-    else:
-        # objective가 없으면 일반 optuna study 반환 (기존 방식)
-        import optuna
-        return optuna.create_study(
-            study_name=study_name,
-            direction=direction,
-            storage=controller.get_storage(),
-            **kwargs
-        )

aiauto_client-0.1.0/src/aiauto/core.py

@@ -1,257 +0,0 @@
-from os import makedirs, environ
-import tempfile
-from typing import Union, Callable, Dict, Any, Optional
-import optuna
-
-from .serialization import create_study_with_source_serialization, SourceCodeSerializer
-
-
-class AIAutoController:
-    # singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, "_instance"):
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    # singleton pattern
-    def __init__(self):
-        cls = type(self)
-        if not hasattr(cls, "_init"):
-            # singleton pattern
-            # ---------------------
-
-            # TODO token 인증
-            token = environ.get('AIAUTO_TOKEN')
-
-            # mode별 storage 설정
-            mode = environ.get('AIAUTO_MODE', 'single_gpu')
-            if mode == "distributed":
-                # DDP/FSDP pruning callback 지원을 위해 RDBStorage 사용
-                self.storage = optuna.storages.RDBStorage(
-                    url="sqlite:///optuna.db",
-                    engine_kwargs={"connect_args": {"timeout": 10}}
-                )
-            else:
-                # 기본 GrpcStorageProxy (single GPU 등)
-                self.storage = optuna.storages.GrpcStorageProxy(host="localhost", port=13000)
-
-            # artifact storage
-            # TODO 나중에 s3 던 다른 mount 된 경로 건 바꿔야 함
-            makedirs('./artifacts', exist_ok=True)
-            self.artifact_store = optuna.artifacts.FileSystemArtifactStore('./artifacts')
-            # model 저장을 위한 임시 디렉토리
-            self.tmp_dir = tempfile.mkdtemp(prefix=f'ai_auto_tmp_')
-
-            # ---------------------
-            # singleton pattern end
-            cls._init = True
-
-    def get_storage(self):
-        return self.storage
-
-    def get_artifact_store(self) -> Union[
-        optuna.artifacts.FileSystemArtifactStore,
-        optuna.artifacts.Boto3ArtifactStore,
-        optuna.artifacts.GCSArtifactStore,
-    ]:
-        return self.artifact_store
-
-    def get_artifact_tmp_dir(self):
-        return self.tmp_dir
-
-    def create_study_with_serialization(
-        self,
-        objective: Callable,
-        study_name: str,
-        direction: str = 'minimize',
-        sampler: Optional[optuna.samplers.BaseSampler] = None,
-        pruner: Optional[optuna.pruners.BasePruner] = None,
-        **optuna_kwargs
-    ) -> 'StudyWrapper':
-        """
-        소스코드 직렬화를 사용하여 Study 생성
-        
-        Args:
-            objective: HPO에 사용할 objective 함수
-            study_name: Study 이름
-            direction: 최적화 방향 ('minimize' 또는 'maximize')
-            sampler: Optuna sampler (기본값: TPESampler)
-            pruner: Optuna pruner
-            **optuna_kwargs: optuna.create_study에 전달할 추가 인자
-            
-        Returns:
-            StudyWrapper 객체 (Optuna Study 호환)
-        """
-        study_config = {
-            'study_name': study_name,
-            'direction': direction,
-            'sampler': sampler.__class__.__name__ if sampler else 'TPESampler',
-            'pruner': pruner.__class__.__name__ if pruner else None,
-        }
-        
-        # 소스코드 직렬화
-        serialized_objective, processed_config = create_study_with_source_serialization(
-            objective, study_config, **optuna_kwargs
-        )
-        
-        # StudyWrapper 생성 (실제 gRPC 전송은 optimize 시점에)
-        return StudyWrapper(
-            serialized_objective=serialized_objective,
-            study_config=processed_config,
-            storage=self.storage,
-            artifact_store=self.artifact_store
-        )
-
-
-class TrialController:
-    def __init__(self, trial: optuna.trial.Trial):
-        self.trial = trial
-        self.logger = optuna.logging.get_logger("optuna")
-        self.logs = []
-
-    def get_trial(self) -> optuna.trial.Trial:
-        return self.trial
-
-    def log(self, value: str):
-        # optuna dashboard 에 log 를 확인하는 기능이 없어서 user_attribute 에 log를 확인할 수 있게 추가
-        self.logs.append(value)
-        self.trial.set_user_attr('logs', ' '.join([f"[{i+1:05d}] {log}" for i, log in enumerate(self.logs)]))
-        # 실제 log 를 trial_number 랑 같이 확인할 수 있게
-        self.logger.info(f'\ntrial_number: {self.trial.number}, {value}')
-
-
-# 용량 제한으로 상위 N개의 trial artifact 만 유지
-class CallbackTopNArtifact:
-    def __init__(
-        self,
-        artifact_store: Union[
-            optuna.artifacts.FileSystemArtifactStore,
-            optuna.artifacts.Boto3ArtifactStore,
-            optuna.artifacts.GCSArtifactStore,
-        ],
-        artifact_attr_name: str = 'artifact_id',
-        n_keep: int = 5,
-    ):
-        self.artifact_store = artifact_store
-        self.check_attr_name = artifact_attr_name
-        self.n_keep = n_keep
-
-    def __call__(self, study: optuna.study.Study, trial: optuna.trial.FrozenTrial):
-        # COMPLETE 상태이고 artifact를 가진 trial들만 정렬
-        finished_with_artifacts = [
-            t for t in study.trials
-            if t.state == optuna.trial.TrialState.COMPLETE and self.check_attr_name in t.user_attrs
-        ]
-
-        # 방향에 따라 정렬 (maximize면 내림차순, minimize면 오름차순)
-        reverse_sort = study.direction == optuna.study.StudyDirection.MAXIMIZE
-        finished_with_artifacts.sort(key=lambda t: t.value, reverse=reverse_sort)
-
-        # 상위 n_keep개 초과하는 trial들의 artifact 삭제
-        for old_trial in finished_with_artifacts[self.n_keep:]:
-            artifact_id = old_trial.user_attrs.get(self.check_attr_name)
-            if artifact_id:
-                try:
-                    self.artifact_store.remove(artifact_id)
-                    # user_attr에서도 제거
-                    study._storage.set_trial_user_attr(old_trial._trial_id, self.check_attr_name, None)
-                except Exception as e:
-                    print(f"Warning: Failed to remove artifact {artifact_id}: {e}")
-
-
-class StudyWrapper:
-    """
-    Optuna Study 호환성을 제공하는 래퍼 클래스
-    
-    이 클래스는 소스코드 직렬화된 objective 함수를 관리하고
-    실제 HPO 실행을 위해 gRPC 백엔드와 통신합니다.
-    """
-    
-    def __init__(
-        self,
-        serialized_objective: Dict[str, Any],
-        study_config: Dict[str, Any],
-        storage,
-        artifact_store
-    ):
-        self.serialized_objective = serialized_objective
-        self.study_config = study_config
-        self.storage = storage
-        self.artifact_store = artifact_store
-        self._local_study = None  # 로컬 테스트용
-        
-    def optimize(
-        self,
-        n_trials: int = 100,
-        n_jobs: int = 1,
-        callbacks: Optional[list] = None,
-        **kwargs
-    ):
-        """
-        HPO 최적화 실행
-        
-        실제 구현에서는 gRPC를 통해 백엔드로 전송하지만,
-        현재는 로컬에서 역직렬화하여 테스트합니다.
-        """
-        print("🚀 Starting HPO optimization with source code serialization...")
-        print(f"📊 Study: {self.study_config['study_name']}")
-        print(f"🎯 Direction: {self.study_config['direction']}")
-        print(f"🔢 Trials: {n_trials}")
-        
-        try:
-            # 소스코드 역직렬화로 objective 함수 복원
-            objective_func = SourceCodeSerializer.deserialize_objective(
-                self.serialized_objective
-            )
-            print("✅ Objective function deserialized successfully")
-            
-            # 로컬 Study 생성 (실제로는 gRPC 통신)
-            self._local_study = optuna.create_study(
-                study_name=self.study_config['study_name'],
-                direction=self.study_config['direction'],
-                storage=self.storage,
-                load_if_exists=True
-            )
-            
-            # 최적화 실행
-            self._local_study.optimize(
-                objective_func,
-                n_trials=n_trials,
-                n_jobs=n_jobs,
-                callbacks=callbacks or [],
-                **kwargs
-            )
-            
-            print(f"🎉 Optimization completed! Best value: {self.best_value}")
-            
-        except Exception as e:
-            print(f"❌ Optimization failed: {e}")
-            raise
-    
-    @property
-    def best_trial(self):
-        """최고 성능 Trial 반환"""
-        if self._local_study:
-            return self._local_study.best_trial
-        return None
-    
-    @property
-    def best_value(self):
-        """최고 성능 값 반환"""
-        if self._local_study:
-            return self._local_study.best_value
-        return None
-    
-    @property
-    def best_params(self):
-        """최고 성능 하이퍼파라미터 반환"""
-        if self._local_study:
-            return self._local_study.best_params
-        return None
-    
-    @property
-    def trials(self):
-        """모든 Trial 목록 반환"""
-        if self._local_study:
-            return self._local_study.trials
-        return []

aiauto_client-0.1.0/src/aiauto/serialization.py

@@ -1,138 +0,0 @@
-"""
-Source Code Serialization Module
-
-이 모듈은 Python 버전 간 호환성을 위해 CloudPickle 대신 
-inspect.getsource를 사용한 소스코드 직렬화 방식을 제공합니다.
-"""
-
-import inspect
-import types
-from typing import Callable, Dict, Any, Tuple
-
-
-class SourceCodeSerializer:
-    """Objective 함수를 소스코드로 직렬화하는 클래스"""
-    
-    @staticmethod
-    def serialize_objective(objective_func: Callable) -> Dict[str, Any]:
-        """
-        Objective 함수를 소스코드로 직렬화
-        
-        Args:
-            objective_func: 직렬화할 objective 함수
-            
-        Returns:
-            직렬화된 데이터 딕셔너리
-            - source_code: 함수의 소스코드 문자열
-            - func_name: 함수 이름
-            - dependencies: 필요한 import 구문들
-        """
-        try:
-            # 함수 소스코드 추출
-            source_code = inspect.getsource(objective_func)
-            func_name = objective_func.__name__
-            
-            # 함수가 정의된 모듈의 정보 추출
-            module = inspect.getmodule(objective_func)
-            dependencies = []
-            
-            if module and hasattr(module, '__file__'):
-                # 모듈에서 import 구문들 추출 (간단한 방식)
-                with open(module.__file__, 'r') as f:
-                    module_source = f.read()
-                
-                # import 구문 추출 (개선된 파싱 필요시 ast 모듈 사용)
-                lines = module_source.split('\n')
-                for line in lines:
-                    line = line.strip()
-                    if line.startswith('import ') or line.startswith('from '):
-                        # 기본적인 import 구문만 추출
-                        if not any(skip in line for skip in ['client', '__', 'relative']):
-                            dependencies.append(line)
-            
-            return {
-                'source_code': source_code,
-                'func_name': func_name,
-                'dependencies': dependencies,
-                'serialization_method': 'source_code'
-            }
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to serialize objective function: {e}")
-    
-    @staticmethod
-    def deserialize_objective(serialized_data: Dict[str, Any]) -> Callable:
-        """
-        직렬화된 데이터로부터 objective 함수를 복원
-        
-        Args:
-            serialized_data: serialize_objective에서 생성된 데이터
-            
-        Returns:
-            복원된 objective 함수
-        """
-        try:
-            source_code = serialized_data['source_code']
-            func_name = serialized_data['func_name']
-            dependencies = serialized_data.get('dependencies', [])
-            
-            # 실행 네임스페이스 생성
-            exec_namespace = {'__builtins__': __builtins__}
-            
-            # 의존성 import 실행
-            for dep in dependencies:
-                try:
-                    exec(dep, exec_namespace)
-                except Exception as import_error:
-                    # import 실패는 경고만 하고 계속 진행
-                    print(f"Warning: Failed to import dependency '{dep}': {import_error}")
-            
-            # 소스코드 실행
-            exec(source_code, exec_namespace)
-            
-            # 함수 객체 추출
-            if func_name not in exec_namespace:
-                raise NameError(f"Function '{func_name}' not found in executed namespace")
-            
-            objective_func = exec_namespace[func_name]
-            
-            if not callable(objective_func):
-                raise TypeError(f"'{func_name}' is not callable")
-            
-            return objective_func
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to deserialize objective function: {e}")
-
-
-def create_study_with_source_serialization(
-    objective: Callable,
-    study_config: Dict[str, Any],
-    **optuna_kwargs
-) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-    """
-    소스코드 직렬화를 사용하여 study 생성 준비
-    
-    Args:
-        objective: HPO에 사용할 objective 함수
-        study_config: study 설정 (name, direction, sampler, pruner 등)
-        **optuna_kwargs: optuna.create_study에 전달할 추가 인자들
-        
-    Returns:
-        Tuple[serialized_objective, study_config]
-        - serialized_objective: 직렬화된 objective 함수 데이터
-        - study_config: study 설정 데이터
-    """
-    # Objective 함수 직렬화
-    serialized_objective = SourceCodeSerializer.serialize_objective(objective)
-    
-    # Study 설정 정리
-    processed_config = {
-        'study_name': study_config.get('study_name', 'unnamed_study'),
-        'direction': study_config.get('direction', 'minimize'),
-        'sampler': study_config.get('sampler', 'TPESampler'),
-        'pruner': study_config.get('pruner', None),
-        'optuna_kwargs': optuna_kwargs
-    }
-    
-    return serialized_objective, processed_config

aiauto_client-0.1.0/src/aiauto_client.egg-info/requires.txt

@@ -1,4 +0,0 @@
-optuna>=3.0.0
-grpcio>=1.50.0
-grpcio-tools>=1.50.0
-protobuf>=4.0.0