aiauto-client 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

aiauto/__init__.py

@@ -1,5 +1,7 @@
 from .core import AIAutoController, TrialController, CallbackTopNArtifact, StudyWrapper
-from .serialization import SourceCodeSerializer, create_study_with_source_serialization
+from .api import create_study
+from ._config import AIAUTO_API_TARGET
+from .constants import RUNTIME_IMAGES
 
 __version__ = "0.1.0"
 
@@ -8,43 +10,7 @@ __all__ = [
     '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
-        )
+    'create_study',
+    'AIAUTO_API_TARGET',
+    'RUNTIME_IMAGES',
+]

aiauto/_config.py

@@ -0,0 +1,3 @@
+# 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"

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/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/core.py

@@ -1,50 +1,50 @@
-from os import makedirs, environ
+from os import makedirs
 import tempfile
-from typing import Union, Callable, Dict, Any, Optional
+from typing import Union, Optional, List, Dict, Callable
 import optuna
-
-from .serialization import create_study_with_source_serialization, SourceCodeSerializer
+from .http_client import ConnectRPCClient
+from .serializer import serialize, build_requirements
+from ._config import AIAUTO_API_TARGET
 
 
 class AIAutoController:
-    # singleton pattern
-    def __new__(cls, *args, **kwargs):
-        if not hasattr(cls, "_instance"):
-            cls._instance = super().__new__(cls)
-        return cls._instance
+    _instances = {}
 
-    # singleton pattern
-    def __init__(self):
-        cls = type(self)
-        if not hasattr(cls, "_init"):
-            # singleton pattern
-            # ---------------------
+    def __new__(cls, token: str):
+        if token not in cls._instances:
+            cls._instances[token] = super().__new__(cls)
+        return cls._instances[token]
 
-            # TODO token 인증
-            token = environ.get('AIAUTO_TOKEN')
+    def __init__(self, token: str):
+        if hasattr(self, 'token') and self.token == token:
+            return
 
-            # 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)
+        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', '')
 
-            # 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_')
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize workspace: {e}") from e
 
-            # ---------------------
-            # singleton pattern end
-            cls._init = True
+        # 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
@@ -59,49 +59,6 @@ class AIAutoController:
     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):
@@ -160,98 +117,81 @@ class CallbackTopNArtifact:
 
 
 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 __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,
-        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}")
-        
+        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:
-            # 소스코드 역직렬화로 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
-            )
+            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._local_study.optimize(
-                objective_func,
-                n_trials=n_trials,
-                n_jobs=n_jobs,
-                callbacks=callbacks or [],
-                **kwargs
+            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}
             )
             
-            print(f"🎉 Optimization completed! Best value: {self.best_value}")
-            
+            # 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:
-            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 []
+            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/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.pangyo.ainode.ai:443"
+            # Convert to "https://api.aiauto.pangyo.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/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.dist-info → aiauto_client-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiauto-client
-Version: 0.1.0
+Version: 0.1.2
 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.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+aiauto/__init__.py,sha256=TgD2ZvIHb7oKJb-HjUl3WfXXtuWLien0sybSy9onjL8,395
+aiauto/_config.py,sha256=DaRTIZlph9T3iuW-Cy4fkw8i3bXB--gMtW947SLZZNs,159
+aiauto/api.py,sha256=hzoVZMwKtH2EaAM1bY67grp6cenltCl8kdG8YHPegvk,1517
+aiauto/constants.py,sha256=UhDCLFoPE89XrHB3SEnZR3YUuzajgugMGX80KYx_qc0,939
+aiauto/core.py,sha256=uvAuSIL6CrIDfRBnBjN6SPFXD1ZJa7w7afNzmDyvzLM,7777
+aiauto/http_client.py,sha256=t1gxeM5-d5bsVoFWgaNcTrt_WWUXuMuxge9gDlEqhoA,2086
+aiauto/serializer.py,sha256=_iPtEoqW8RTKOZ6UrC7CzOqoangpPYzeL7MQfIdmov8,1568
+aiauto_client-0.1.2.dist-info/METADATA,sha256=Yez_Igblnrkc0f6fAk5YQ7HHkqv6xRjZ_jeHak3vzzk,3335
+aiauto_client-0.1.2.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+aiauto_client-0.1.2.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
+aiauto_client-0.1.2.dist-info/RECORD,,

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.dist-info/RECORD

@@ -1,7 +0,0 @@
-aiauto/__init__.py,sha256=VvEM3L0NZGrHi3kHV_gSRf8X2baqLDPOSbArgd6LpaI,1353
-aiauto/core.py,sha256=GKCF24GA25QCu8n2q3YXnff4Sb3Dfx1yKFvE7QZ8108,9182
-aiauto/serialization.py,sha256=6Rb5k01hx7uXaLt1XmUrmn1KzMjxsYinzi4fjglc3jw,5137
-aiauto_client-0.1.0.dist-info/METADATA,sha256=inimyQ0HuHH8mWkYUOP1FpXez506z1i8_oi0UVBSwsE,2510
-aiauto_client-0.1.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-aiauto_client-0.1.0.dist-info/top_level.txt,sha256=Sk2ctO9_Bf_tAPwq1x6Vfl6OuL29XzwMTO4F_KG6oJE,7
-aiauto_client-0.1.0.dist-info/RECORD,,