aiauto-client 0.1.9__tar.gz → 0.1.10__tar.gz

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: aiauto-client
-Version: 0.1.9
+Version: 0.1.10
 Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
 Author-email: AIAuto Team <ainode@zeroone.ai>
-Project-URL: Homepage, https://dashboard.aiauto.pangyo.ainode.ai
-Project-URL: Repository, https://dashboard.aiauto.pangyo.ainode.ai
-Project-URL: Documentation, https://dashboard.aiauto.pangyo.ainode.ai
+Project-URL: Homepage, https://dashboard.common.aiauto.pangyo.ainode.ai
+Project-URL: Repository, https://dashboard.common.aiauto.pangyo.ainode.ai
+Project-URL: Documentation, https://dashboard.common.aiauto.pangyo.ainode.ai
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -481,3 +481,137 @@ study.tell(trial, ret)
 ```bash
 make build push
 ```
+
+
+## LLM을 위한 설명 (for code assistants / agents)
+
+이 섹션은 **코드 어시스턴트/에이전트**가 AIAuto를 자동으로 사용할 때 참고하는 규칙 모음입니다.  
+사람 사용자는 위 본문 가이드를 우선적으로 따르세요.
+
+### 1) 목적과 사용 흐름 (요약)
+- AIAuto는 **Optuna를 Kubernetes에서 분산 실행**하도록 해주는 Python 클라이언트입니다.
+- 두 가지 흐름을 지원합니다:
+    1) `StudyWrapper.optimize(...)` → 원격(K8s) 병렬 실행
+    2) `StudyWrapper.get_study()` → 실제 `optuna.Study` 로드 후 **ask/tell** 직접 사용
+
+### 2) 네트워크/도메인 규칙 (필수)
+- **Connect RPC (HTTPS/443)**: `https://api.aiauto.pangyo.ainode.ai`
+- **Optuna Storage (gRPC, 평문 h2c/13000)**:  
+  `{userID}.journal-grpc-storage-proxy.aiauto.pangyo.ainode.ai:13000`  
+  → **항상 평문(h2c)**. 443/TLS 시도 **금지**.
+- 대시보드(웹): `https://dashboard.aiauto.pangyo.ainode.ai`
+
+### 3) 호출 순서 (결정 트리)
+1) 컨트롤러 생성: `AIAutoController(token)` → 토큰 검증 & 워크스페이스/엔드포인트 획득
+2) 스터디 생성: `controller.create_study(study_name, direction=… | directions=[…])`
+    - 제약: `direction` **또는** `directions` 중 **하나만** 사용
+3) 분기:
+    - **분산 실행**: `study.optimize(objective, n_trials, parallelism, …)`
+    - **네이티브 제어**: `real = study.get_study()` 후 `real.ask() / real.tell(...)`
+
+### 4) 인자/작성 제약(LLM이 반드시 지킬 불변식)
+- `direction` **XOR** `directions` (동시 지정 금지)
+- `requirements_file` **XOR** `requirements_list` (동시 지정 금지)
+- `objective` 작성 규칙:
+    - 모든 **import는 함수 내부**에 작성
+    - 함수 시그니처에 **타입 힌트 금지** (예: `trial: optuna.trial.Trial` 사용 금지)
+    - 로컬 파일 경로 의존 금지(원격에서 다운로드/생성)
+
+### 5) 최소 예제
+
+#### (A) 분산 실행
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study('exp1', direction='minimize')
+
+def objective(trial):
+import numpy as np
+x = trial.suggest_float('x', -10, 10)
+return (x - 1.23) ** 2
+
+study.optimize(
+objective,
+n_trials=64,
+parallelism=8,
+requirements_list=['numpy'],
+)
+```
+
+#### (B) ask/tell (실제 optuna.Study 사용)
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+sw = controller.create_study('manual', direction='minimize')
+
+real = sw.get_study()           # 실제 optuna.Study 로드 (gRPC: h2c 13000)
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 2) ** 2)
+```
+
+### 6) 에러 응답 템플릿(자동 응답 가이드)
+- 초기화/토큰 문제 감지:
+    - “대시보드에서 토큰을 재발급한 뒤 다시 시도하세요: https://dashboard.aiauto.pangyo.ainode.ai”
+- `get_study()` 연결 실패(스토리지 준비 전):
+    - “Workspace/Storage가 아직 준비 중일 수 있어요. 잠시 후 다시 시도하거나 대시보드에서 상태를 확인해 주세요.”
+
+### 7) 금지/주의 목록
+- gRPC를 **443/TLS**로 붙이려는 시도 **금지** (항상 **13000/h2c**).
+- `direction & directions`, `requirements_file & requirements_list` 동시 지정 **금지**.
+- `objective`는 함수 내부 import, 타입 힌트 금지, 로컬 파일 경로 의존 금지.
+
+### 8) Optuna 호환성 (Sampler/Pruner & Study API)
+- **Sampler/Pruner 호환**: `create_study()`에 **Optuna 원본** `sampler`/`pruner` 인스턴스를 그대로 전달하면 됩니다.  
+  Study 생성 시 지정된 sampler/pruner는 **Optuna Journal Storage**에 저장되고, 원격 Pod에서 `optuna.load_study()`로 로드될 때 **자동으로 동일 설정이 적용**됩니다. 별도 복원 로직이 필요 없습니다.
+- **네이티브 Study 사용**: `StudyWrapper.get_study()`는 **실제 `optuna.Study` 객체**를 반환합니다.  
+  따라서 `best_trial`, `best_trials`(다중 목적), `trials_dataframe()`, `get_trials()`, `ask()/tell()` 등 **Optuna API를 그대로** 사용할 수 있습니다.
+
+**공식 문서 링크**
+- Samplers: https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+- Pruners: https://optuna.readthedocs.io/en/stable/reference/pruners.html
+- Study API: https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html
+
+#### 예시: Sampler/Pruner 그대로 사용
+```python
+import optuna, aiauto
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study(
+study_name='cnn',
+direction='minimize',
+sampler=optuna.samplers.TPESampler(seed=42),
+pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+)
+
+def objective(trial):
+import numpy as np
+lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+return (np.log10(lr) + 2) ** 2
+
+study.optimize(objective, n_trials=50, parallelism=4)
+```
+
+#### 예시: get_study() 후 Optuna API 그대로 사용
+```python
+# 실제 optuna.Study 로드
+real = study.get_study()
+
+# 단일 목적: best_trial
+print('best value:', real.best_trial.value)
+print('best params:', real.best_trial.params)
+
+# (옵션) 다중 목적: Pareto front
+# print(real.best_trials)  # multi-objective일 때 사용
+
+# 분석/시각화용 DataFrame
+df = real.trials_dataframe(attrs=('number', 'value', 'params', 'state'))
+print(df.head())
+
+# 세밀 제어: ask/tell
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 1.23) ** 2)
+```

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/README.md

@@ -454,3 +454,137 @@ study.tell(trial, ret)
 ```bash
 make build push
 ```
+
+
+## LLM을 위한 설명 (for code assistants / agents)
+
+이 섹션은 **코드 어시스턴트/에이전트**가 AIAuto를 자동으로 사용할 때 참고하는 규칙 모음입니다.  
+사람 사용자는 위 본문 가이드를 우선적으로 따르세요.
+
+### 1) 목적과 사용 흐름 (요약)
+- AIAuto는 **Optuna를 Kubernetes에서 분산 실행**하도록 해주는 Python 클라이언트입니다.
+- 두 가지 흐름을 지원합니다:
+    1) `StudyWrapper.optimize(...)` → 원격(K8s) 병렬 실행
+    2) `StudyWrapper.get_study()` → 실제 `optuna.Study` 로드 후 **ask/tell** 직접 사용
+
+### 2) 네트워크/도메인 규칙 (필수)
+- **Connect RPC (HTTPS/443)**: `https://api.aiauto.pangyo.ainode.ai`
+- **Optuna Storage (gRPC, 평문 h2c/13000)**:  
+  `{userID}.journal-grpc-storage-proxy.aiauto.pangyo.ainode.ai:13000`  
+  → **항상 평문(h2c)**. 443/TLS 시도 **금지**.
+- 대시보드(웹): `https://dashboard.aiauto.pangyo.ainode.ai`
+
+### 3) 호출 순서 (결정 트리)
+1) 컨트롤러 생성: `AIAutoController(token)` → 토큰 검증 & 워크스페이스/엔드포인트 획득
+2) 스터디 생성: `controller.create_study(study_name, direction=… | directions=[…])`
+    - 제약: `direction` **또는** `directions` 중 **하나만** 사용
+3) 분기:
+    - **분산 실행**: `study.optimize(objective, n_trials, parallelism, …)`
+    - **네이티브 제어**: `real = study.get_study()` 후 `real.ask() / real.tell(...)`
+
+### 4) 인자/작성 제약(LLM이 반드시 지킬 불변식)
+- `direction` **XOR** `directions` (동시 지정 금지)
+- `requirements_file` **XOR** `requirements_list` (동시 지정 금지)
+- `objective` 작성 규칙:
+    - 모든 **import는 함수 내부**에 작성
+    - 함수 시그니처에 **타입 힌트 금지** (예: `trial: optuna.trial.Trial` 사용 금지)
+    - 로컬 파일 경로 의존 금지(원격에서 다운로드/생성)
+
+### 5) 최소 예제
+
+#### (A) 분산 실행
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study('exp1', direction='minimize')
+
+def objective(trial):
+import numpy as np
+x = trial.suggest_float('x', -10, 10)
+return (x - 1.23) ** 2
+
+study.optimize(
+objective,
+n_trials=64,
+parallelism=8,
+requirements_list=['numpy'],
+)
+```
+
+#### (B) ask/tell (실제 optuna.Study 사용)
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+sw = controller.create_study('manual', direction='minimize')
+
+real = sw.get_study()           # 실제 optuna.Study 로드 (gRPC: h2c 13000)
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 2) ** 2)
+```
+
+### 6) 에러 응답 템플릿(자동 응답 가이드)
+- 초기화/토큰 문제 감지:
+    - “대시보드에서 토큰을 재발급한 뒤 다시 시도하세요: https://dashboard.aiauto.pangyo.ainode.ai”
+- `get_study()` 연결 실패(스토리지 준비 전):
+    - “Workspace/Storage가 아직 준비 중일 수 있어요. 잠시 후 다시 시도하거나 대시보드에서 상태를 확인해 주세요.”
+
+### 7) 금지/주의 목록
+- gRPC를 **443/TLS**로 붙이려는 시도 **금지** (항상 **13000/h2c**).
+- `direction & directions`, `requirements_file & requirements_list` 동시 지정 **금지**.
+- `objective`는 함수 내부 import, 타입 힌트 금지, 로컬 파일 경로 의존 금지.
+
+### 8) Optuna 호환성 (Sampler/Pruner & Study API)
+- **Sampler/Pruner 호환**: `create_study()`에 **Optuna 원본** `sampler`/`pruner` 인스턴스를 그대로 전달하면 됩니다.  
+  Study 생성 시 지정된 sampler/pruner는 **Optuna Journal Storage**에 저장되고, 원격 Pod에서 `optuna.load_study()`로 로드될 때 **자동으로 동일 설정이 적용**됩니다. 별도 복원 로직이 필요 없습니다.
+- **네이티브 Study 사용**: `StudyWrapper.get_study()`는 **실제 `optuna.Study` 객체**를 반환합니다.  
+  따라서 `best_trial`, `best_trials`(다중 목적), `trials_dataframe()`, `get_trials()`, `ask()/tell()` 등 **Optuna API를 그대로** 사용할 수 있습니다.
+
+**공식 문서 링크**
+- Samplers: https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+- Pruners: https://optuna.readthedocs.io/en/stable/reference/pruners.html
+- Study API: https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html
+
+#### 예시: Sampler/Pruner 그대로 사용
+```python
+import optuna, aiauto
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study(
+study_name='cnn',
+direction='minimize',
+sampler=optuna.samplers.TPESampler(seed=42),
+pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+)
+
+def objective(trial):
+import numpy as np
+lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+return (np.log10(lr) + 2) ** 2
+
+study.optimize(objective, n_trials=50, parallelism=4)
+```
+
+#### 예시: get_study() 후 Optuna API 그대로 사용
+```python
+# 실제 optuna.Study 로드
+real = study.get_study()
+
+# 단일 목적: best_trial
+print('best value:', real.best_trial.value)
+print('best params:', real.best_trial.params)
+
+# (옵션) 다중 목적: Pareto front
+# print(real.best_trials)  # multi-objective일 때 사용
+
+# 분석/시각화용 DataFrame
+df = real.trials_dataframe(attrs=('number', 'value', 'params', 'state'))
+print(df.head())
+
+# 세밀 제어: ask/tell
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 1.23) ** 2)
+```

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiauto-client"
-version = "0.1.9"
+version = "0.1.10"
 description = "AI Auto HPO (Hyperparameter Optimization) Client Library"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -33,9 +33,9 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://dashboard.aiauto.pangyo.ainode.ai"
-Repository = "https://dashboard.aiauto.pangyo.ainode.ai"
-Documentation = "https://dashboard.aiauto.pangyo.ainode.ai"
+Homepage = "https://dashboard.common.aiauto.pangyo.ainode.ai"
+Repository = "https://dashboard.common.aiauto.pangyo.ainode.ai"
+Documentation = "https://dashboard.common.aiauto.pangyo.ainode.ai"
 
 [tool.setuptools.packages.find]
 where = ["src"]

aiauto_client-0.1.10/src/aiauto/_config.py

@@ -0,0 +1,2 @@
+# For Connect RPC over HTTP
+AIAUTO_API_TARGET = "api.common.aiauto.pangyo.ainode.ai:443"

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/src/aiauto/core.py

@@ -31,16 +31,8 @@ class AIAutoController:
             if not host_external:
                 raise RuntimeError("No storage host returned from EnsureWorkspace")
 
-            # Parse host and port
-            if ':' in host_external:
-                host, port_str = host_external.rsplit(':', 1)
-                port = int(port_str)
-            else:
-                host = host_external
-                port = 443  # Default to HTTPS port
-            
-            # Create storage with TLS support for port 443
-            self.storage = self._create_storage_with_tls(host, port)
+            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', '')
@@ -49,7 +41,7 @@ class AIAutoController:
         except Exception as e:
             raise RuntimeError(
                 f"Failed to initialize workspace: {e}\n"
-                "Please delete and reissue your token from the web dashboard at https://dashboard.aiauto.pangyo.ainode.ai"
+                "Please delete and reissue your token from the web dashboard at https://dashboard.common.aiauto.pangyo.ainode.ai"
             ) from e
 
         # artifact storage
@@ -57,74 +49,6 @@ class AIAutoController:
         self.artifact_store = optuna.artifacts.FileSystemArtifactStore('./artifacts')
         self.tmp_dir = tempfile.mkdtemp(prefix=f'ai_auto_tmp_')
 
-    def _create_storage_with_tls(self, host: str, port: int):
-        """Create GrpcStorageProxy with automatic TLS detection based on port"""
-        # Port 13000 = internal (plain), Port 443 = external (TLS)
-        if port != 443:
-            # Plain gRPC for internal connections
-            return optuna.storages.GrpcStorageProxy(host=host, port=port)
-        
-        # TLS connection for external access (port 443)
-        import grpc
-        creds = grpc.ssl_channel_credentials()
-        
-        # Try different TLS parameter names for Optuna version compatibility
-        # Try 1: channel_credentials parameter (newer Optuna versions)
-        try:
-            return optuna.storages.GrpcStorageProxy(
-                host=host, 
-                port=port, 
-                channel_credentials=creds
-            )
-        except TypeError:
-            pass
-        
-        # Try 2: ssl boolean parameter
-        try:
-            return optuna.storages.GrpcStorageProxy(
-                host=host, 
-                port=port, 
-                ssl=True
-            )
-        except TypeError:
-            pass
-        
-        # Try 3: use_tls parameter
-        try:
-            return optuna.storages.GrpcStorageProxy(
-                host=host,
-                port=port,
-                use_tls=True
-            )
-        except TypeError:
-            pass
-        
-        # Try 4: secure parameter
-        try:
-            return optuna.storages.GrpcStorageProxy(
-                host=host,
-                port=port,
-                secure=True
-            )
-        except TypeError:
-            pass
-        
-        # Fallback: try to create secure channel manually
-        try:
-            channel = grpc.secure_channel(f"{host}:{port}", creds)
-            # Some Optuna versions might accept a channel directly
-            return optuna.storages.GrpcStorageProxy(channel=channel)
-        except (TypeError, AttributeError):
-            pass
-        
-        # If all attempts fail, raise informative error
-        raise RuntimeError(
-            f"Failed to create TLS connection to {host}:{port}. "
-            "GrpcStorageProxy TLS parameters not recognized. "
-            "Please check Optuna version compatibility. "
-            "Tried: channel_credentials, ssl, use_tls, secure, channel parameters."
-        )
-    
     def get_storage(self):
         return self.storage
 
@@ -253,7 +177,7 @@ class StudyWrapper:
             except Exception as e:
                 raise RuntimeError(
                     "Failed to get study. If this persists, please delete and reissue your token "
-                    "from the web dashboard at https://dashboard.aiauto.pangyo.ainode.ai"
+                    "from the web dashboard at https://dashboard.common.aiauto.pangyo.ainode.ai"
                 ) from e
         return self._study
 

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/src/aiauto/http_client.py

@@ -13,8 +13,8 @@ class ConnectRPCClient:
         if base_url:
             self.base_url = base_url
         else:
-            # AIAUTO_API_TARGET is like "api.aiauto.pangyo.ainode.ai:443"
-            # Convert to "https://api.aiauto.pangyo.ainode.ai"
+            # AIAUTO_API_TARGET is like "api.common.aiauto.pangyo.ainode.ai:443"
+            # Convert to "https://api.common.aiauto.pangyo.ainode.ai"
             host = AIAUTO_API_TARGET.split(':')[0]
             self.base_url = f"https://{host}"
         

{aiauto_client-0.1.9 → aiauto_client-0.1.10}/src/aiauto_client.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: aiauto-client
-Version: 0.1.9
+Version: 0.1.10
 Summary: AI Auto HPO (Hyperparameter Optimization) Client Library
 Author-email: AIAuto Team <ainode@zeroone.ai>
-Project-URL: Homepage, https://dashboard.aiauto.pangyo.ainode.ai
-Project-URL: Repository, https://dashboard.aiauto.pangyo.ainode.ai
-Project-URL: Documentation, https://dashboard.aiauto.pangyo.ainode.ai
+Project-URL: Homepage, https://dashboard.common.aiauto.pangyo.ainode.ai
+Project-URL: Repository, https://dashboard.common.aiauto.pangyo.ainode.ai
+Project-URL: Documentation, https://dashboard.common.aiauto.pangyo.ainode.ai
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -481,3 +481,137 @@ study.tell(trial, ret)
 ```bash
 make build push
 ```
+
+
+## LLM을 위한 설명 (for code assistants / agents)
+
+이 섹션은 **코드 어시스턴트/에이전트**가 AIAuto를 자동으로 사용할 때 참고하는 규칙 모음입니다.  
+사람 사용자는 위 본문 가이드를 우선적으로 따르세요.
+
+### 1) 목적과 사용 흐름 (요약)
+- AIAuto는 **Optuna를 Kubernetes에서 분산 실행**하도록 해주는 Python 클라이언트입니다.
+- 두 가지 흐름을 지원합니다:
+    1) `StudyWrapper.optimize(...)` → 원격(K8s) 병렬 실행
+    2) `StudyWrapper.get_study()` → 실제 `optuna.Study` 로드 후 **ask/tell** 직접 사용
+
+### 2) 네트워크/도메인 규칙 (필수)
+- **Connect RPC (HTTPS/443)**: `https://api.aiauto.pangyo.ainode.ai`
+- **Optuna Storage (gRPC, 평문 h2c/13000)**:  
+  `{userID}.journal-grpc-storage-proxy.aiauto.pangyo.ainode.ai:13000`  
+  → **항상 평문(h2c)**. 443/TLS 시도 **금지**.
+- 대시보드(웹): `https://dashboard.aiauto.pangyo.ainode.ai`
+
+### 3) 호출 순서 (결정 트리)
+1) 컨트롤러 생성: `AIAutoController(token)` → 토큰 검증 & 워크스페이스/엔드포인트 획득
+2) 스터디 생성: `controller.create_study(study_name, direction=… | directions=[…])`
+    - 제약: `direction` **또는** `directions` 중 **하나만** 사용
+3) 분기:
+    - **분산 실행**: `study.optimize(objective, n_trials, parallelism, …)`
+    - **네이티브 제어**: `real = study.get_study()` 후 `real.ask() / real.tell(...)`
+
+### 4) 인자/작성 제약(LLM이 반드시 지킬 불변식)
+- `direction` **XOR** `directions` (동시 지정 금지)
+- `requirements_file` **XOR** `requirements_list` (동시 지정 금지)
+- `objective` 작성 규칙:
+    - 모든 **import는 함수 내부**에 작성
+    - 함수 시그니처에 **타입 힌트 금지** (예: `trial: optuna.trial.Trial` 사용 금지)
+    - 로컬 파일 경로 의존 금지(원격에서 다운로드/생성)
+
+### 5) 최소 예제
+
+#### (A) 분산 실행
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study('exp1', direction='minimize')
+
+def objective(trial):
+import numpy as np
+x = trial.suggest_float('x', -10, 10)
+return (x - 1.23) ** 2
+
+study.optimize(
+objective,
+n_trials=64,
+parallelism=8,
+requirements_list=['numpy'],
+)
+```
+
+#### (B) ask/tell (실제 optuna.Study 사용)
+```python
+import aiauto, optuna
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+sw = controller.create_study('manual', direction='minimize')
+
+real = sw.get_study()           # 실제 optuna.Study 로드 (gRPC: h2c 13000)
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 2) ** 2)
+```
+
+### 6) 에러 응답 템플릿(자동 응답 가이드)
+- 초기화/토큰 문제 감지:
+    - “대시보드에서 토큰을 재발급한 뒤 다시 시도하세요: https://dashboard.aiauto.pangyo.ainode.ai”
+- `get_study()` 연결 실패(스토리지 준비 전):
+    - “Workspace/Storage가 아직 준비 중일 수 있어요. 잠시 후 다시 시도하거나 대시보드에서 상태를 확인해 주세요.”
+
+### 7) 금지/주의 목록
+- gRPC를 **443/TLS**로 붙이려는 시도 **금지** (항상 **13000/h2c**).
+- `direction & directions`, `requirements_file & requirements_list` 동시 지정 **금지**.
+- `objective`는 함수 내부 import, 타입 힌트 금지, 로컬 파일 경로 의존 금지.
+
+### 8) Optuna 호환성 (Sampler/Pruner & Study API)
+- **Sampler/Pruner 호환**: `create_study()`에 **Optuna 원본** `sampler`/`pruner` 인스턴스를 그대로 전달하면 됩니다.  
+  Study 생성 시 지정된 sampler/pruner는 **Optuna Journal Storage**에 저장되고, 원격 Pod에서 `optuna.load_study()`로 로드될 때 **자동으로 동일 설정이 적용**됩니다. 별도 복원 로직이 필요 없습니다.
+- **네이티브 Study 사용**: `StudyWrapper.get_study()`는 **실제 `optuna.Study` 객체**를 반환합니다.  
+  따라서 `best_trial`, `best_trials`(다중 목적), `trials_dataframe()`, `get_trials()`, `ask()/tell()` 등 **Optuna API를 그대로** 사용할 수 있습니다.
+
+**공식 문서 링크**
+- Samplers: https://optuna.readthedocs.io/en/stable/reference/samplers/index.html
+- Pruners: https://optuna.readthedocs.io/en/stable/reference/pruners.html
+- Study API: https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html
+
+#### 예시: Sampler/Pruner 그대로 사용
+```python
+import optuna, aiauto
+
+controller = aiauto.AIAutoController('aiauto_xxx')
+study = controller.create_study(
+study_name='cnn',
+direction='minimize',
+sampler=optuna.samplers.TPESampler(seed=42),
+pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+)
+
+def objective(trial):
+import numpy as np
+lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
+return (np.log10(lr) + 2) ** 2
+
+study.optimize(objective, n_trials=50, parallelism=4)
+```
+
+#### 예시: get_study() 후 Optuna API 그대로 사용
+```python
+# 실제 optuna.Study 로드
+real = study.get_study()
+
+# 단일 목적: best_trial
+print('best value:', real.best_trial.value)
+print('best params:', real.best_trial.params)
+
+# (옵션) 다중 목적: Pareto front
+# print(real.best_trials)  # multi-objective일 때 사용
+
+# 분석/시각화용 DataFrame
+df = real.trials_dataframe(attrs=('number', 'value', 'params', 'state'))
+print(df.head())
+
+# 세밀 제어: ask/tell
+t = real.ask()
+x = t.suggest_float('x', -10, 10)
+real.tell(t, (x - 1.23) ** 2)
+```

aiauto_client-0.1.9/src/aiauto/_config.py

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