semvec/pypi-packages huggingface dataset:
axmp-ai-agent-studio 0.1.0
This is a backend service for the AI Agent Studio
Requires Python: <4.0,>=3.12

# AI Agent Manager

AI 에이전트를 관리하는 웹 서비스입니다.

## 🚀 시작하기

### 1. 의존성 설치
```bash
poetry install
```

### 2. 가상환경 활성화
```bash
poetry shell
```

### 3. 서비스 실행
```bash
# 방법 1: 자동으로 Poetry 가상환경 사용 (추천)
python run.py

# 방법 2: Poetry 명령어로 직접 실행
poetry run uvicorn ai_agent_manager.main:app --reload --host 0.0.0.0 --port 8000

# 방법 3: Poetry shell 진입 후 실행
poetry shell
uvicorn ai_agent_manager.main:app --reload
```

### 4. API 문서 확인
서비스 실행 후 다음 URL에서 API 문서를 확인할 수 있습니다:
- Swagger UI: http://localhost:8000/docs
- ReDoc: http://localhost:8000/redoc

## 📦 라이브러리 추가

```bash
# 일반 의존성 추가
poetry add 라이브러리명

# 개발용 의존성 추가
poetry add --group dev 라이브러리명

# 예시
poetry add requests pydantic
poetry add --group dev pytest black flake8
```

## 🛠️ 개발

### 프로젝트 구조
```
ai-agent-manager/
├── src/
│   └── ai_agent_manager/
│       ├── __init__.py
│       └── main.py
├── tests/
├── pyproject.toml
└── README.md
```

### 개발 모드 실행
```bash
uvicorn ai_agent_manager.main:app --reload
```

## 📝 API 엔드포인트

- `GET /` - 기본 환영 메시지
- `GET /health` - 서비스 상태 확인
- `GET /agents` - 에이전트 목록 조회

## cursor에서 venv 선택하기
 - cmd + shift + p
 - Python: select interpreter 선택
 - Python 3.12.10('.venv': Poetry) 선택
 - cmd + , (setting) -> venv 검색 -> path에 ./venv 등록???
nnconvexity 0.1.1
Package for analyzing the convexity of neural networks.
Requires Python: >=3.9

# Convexity of representations
This package contains methods to compute convexity scores to measure convexity of latent representations of neural networks as defined in

Tětková, L., Brüsch, T., Dorszewski, T. et al. On convex decision regions in deep network representations. Nat Commun 16, 5419 (2025). https://doi.org/10.1038/s41467-025-60809-y

**Paper:** [https://www.nature.com/articles/s41467-025-60809-y](https://www.nature.com/articles/s41467-025-60809-y)

**Documentation:** [https://nnconvexity.readthedocs.io/en/latest/](https://nnconvexity.readthedocs.io/en/latest/)

**Source code:** [https://github.com/LenkaTetkova/nnconvexity](https://github.com/LenkaTetkova/nnconvexity)

See [code](https://github.com/LenkaTetkova/Convexity-of-representations.git) for the paper containing also a demo for using this package.

It provides functions for two types of convexity:
- Euclidean: sample points on a segment between two points of the same class and evaluate whether they are classified into the same class.
- graph: approximation of convexity on a manifold -- construct a graph based on nearest neighbors and evaluate proportion of the shortest paths that go through the same class.
clockit-code 0.1.2
A super simple utility to time your python code.
Requires Python: >=3.12

![clockit](images/clockit.png)

# clockit

A super lightweight utility to time your Python code — nothing more, nothing less.

## usage

Install with `pip install clockit-code` or with `uv pip install clockit-code`.

Then import with `from clockit import clockit`

### Example 1: Timing Data Loading
```python
from clockit import clockit
import pandas as pd

with clockit(name="load csv") as ct:
    df = pd.read_csv("big_data.csv")
print(ct)  # load csv: X.XXX seconds
```

### Example 2: Timing Model Training
```python
from clockit import clockit
from sklearn.ensemble import RandomForestClassifier

X, y = ...  # your features and labels
model = RandomForestClassifier()

with clockit(printer=print, name="fit model") as ct:
    model.fit(X, y)
# Output: fit model: X.XXX seconds
```

### Example 3: Batch Processing with Nested Timers
```python
from clockit import clockit
import time

data_batches = [range(1000), range(1000), range(1000)]

with clockit(printer=print, name="total batch processing") as ct_total:
    for i, batch in enumerate(data_batches):
        with clockit(printer=print, name=f"process batch {i+1}") as ct:
            time.sleep(0.5)  # simulate processing
print(ct_total)  # total batch processing: X.XXX seconds
```

### Example 4: Accessing Raw Timing Data
```python
with clockit() as ct:
    # expensive operation
    ...
print(ct.elapsed)   # 1.234 (float seconds)
print(ct.readout)   # 'Time: 1.234 seconds'
```

### Example 5: Custom Formatting
```python
# Custom formatting
def my_printer(msg):
    print(f"⏱️  {msg}")

with clockit(printer=my_printer) as ct:
    time.sleep(1)
```

See more examples in `examples.ipynb`

## why clockit?

- 🪶 Lightweight: zero dependencies, minimal footprint
- 🧩 Drop-in: works anywhere
- 🤫 Silent by default, but easy to log or print
- 🏗️ Perfect for steps, scripts, or experiments
- 🕶️ No configuration, no boilerplate, just timing

## Limitations

- **Wall-clock time only:**
  - clockit uses `time.perf_counter()`, which measures elapsed (wall) time, not CPU time. This includes time spent sleeping or waiting on I/O.
- **Single-threaded timing:**
  - clockit does not account for parallel or asynchronous execution. If your code spawns threads, processes, or async tasks, the timer only tracks the main context and won't reflect per-task durations or concurrency effects.
- **No GPU/CUDA synchronization:**
  - For GPU workloads (e.g., PyTorch, TensorFlow), clockit does not synchronize with CUDA or other accelerators. Measured time may not reflect actual device execution time unless you manually synchronize before/after timing.