Metadata-Version: 2.5
Name: py2autotask
Version: 2.0.2
Summary: Dynamic asynchronous task library
Author: 7yokki, brt222
License-Expression: MIT
Requires-Python: >=3.10
Description-Content-Type: text/markdown

# py2autotask

Dinamik asenkron task kütüphanesi - Python kodunu string olarak derleyip çalıştırabilen güçlü bir task scheduler.

## Özellikler

- **Dinamik Kod Derleme**: Python kodunu string olarak verip runtime'da derleyip çalıştırma
- **Asenkron Task Yönetimi**: asyncio tabanlı tam asenkron task yönetimi
- **Priority Sistemi**: LOW, NORMAL, HIGH, CRITICAL öncelik seviyeleri
- **Retry Mekanizması**: Hata durumunda otomatik yeniden deneme (backoff desteği)
- **Timeout Desteği**: Task'lar için zaman aşımı belirleme
- **Periyodik Task**: Belirli aralıklarla çalışan task'lar (interval, max_runs)
- **Task Kontrolü**: Task'ları durdurma, devam ettirme, yeniden başlatma
- **Event Sistemi**: on_success, on_failure, on_complete, on_retry callback'leri
- **CLI Arayüzü**: Komut satırından task yönetimi (run, batch, list, shell)
- **Global Scheduler**: Varsayılan scheduler ile hızlı kullanım

## Kurulum

```bash
pip install py2autotask
```

veya kaynak koddan:

```bash
pip install -e .
```

## Gereksinimler

- Python >= 3.10
- asyncio (standart kütüphane)

## Hızlı Başlangıç

### Basit Task

```python
import asyncio
from py2autotask import task, get_scheduler

async def main():
    # Task oluştur ve çalıştır
    task(
        "merhaba",
        """
        async def merhaba():
            await asyncio.sleep(1)
            return "Merhaba Dünya!"
        """,
        timeout=5
    )
    
    scheduler = get_scheduler()
    await scheduler.shutdown(timeout=2.0)

asyncio.run(main())
```

### Periyodik Task

```python
task(
    "zamanlayici",
    """
    async def zamanlayici():
        print(f"Çalıştı: {asyncio.get_event_loop().time()}")
    """,
    interval=2.0,  # Her 2 saniyede bir
    max_runs=5     # Toplam 5 kez
)
```

### Retry ile Task

```python
task(
    "api_istek",
    """
    async def api_istek():
        import random
        if random.random() < 0.7:
            raise ValueError("API hatası")
        return "Başarılı"
    """,
    retries=3,           # 3 kez yeniden dene
    retry_delay=1.0,     # 1 saniye bekle
    retry_backoff=2.0    # Her denemede bekleme süresini 2 katına çıkar
)
```

## API Kullanımı

### TaskScheduler Sınıfı

```python
from py2autotask import TaskScheduler, TaskPriority

scheduler = TaskScheduler(
    max_concurrent=10,      # Aynı anda en fazla 10 task
    auto_start=True,        # Otomatik başlat
    default_timeout=30.0,   # Varsayılan timeout
    namespace={"api": my_api}  # Kod içinden erişilebilen değişkenler
)
```

### Task Oluşturma

```python
scheduler.task(
    task_name="task_adi",
    pycode="""
    async def task_adi(data):
        await asyncio.sleep(1)
        return data * 2
    """,
    priority=TaskPriority.HIGH,
    delay=0.0,              # Başlangıç gecikmesi
    timeout=10.0,           # Maksimum çalışma süresi
    interval=None,          # Periyodik için aralık
    max_runs=None,          # Maksimum çalışma sayısı
    retries=0,              # Yeniden deneme sayısı
    retry_delay=1.0,        # Retry gecikmesi
    retry_backoff=1.0,     # Retry backoff çarpanı
    auto_start=True,        # Otomatik başlat
    depends_on=[],          # Bağımlı task'lar
    on_success=None,        # Başarı callback
    on_failure=None,        # Hata callback
    on_complete=None,       # Tamamlanma callback
    on_retry=None,          # Retry callback
    metadata={},            # Meta veri
    tags=[],                # Etiketler
    overwrite=False,        # Üzerine yaz
    api=my_api              # Ek context değişkenleri
)
```

### Task Yönetimi

```python
# Task durdur
scheduler.stop_task("task_adi", wait_current=False)

# Task devam ettir
scheduler.cont_task("task_adi")

# Task yeniden başlat
scheduler.restart_task("task_adi")

# Task sil
scheduler.remove_task("task_adi", cancel_running=True)

# Task'ı hemen çalıştır (periyodik task için)
scheduler.trigger_task("task_adi", arg1, arg2, kwarg=value)
```

### Runtime Konfigürasyon

```python
scheduler.config_task(
    "task_adi",
    pycode="...",           # Kodu güncelle
    priority=TaskPriority.CRITICAL,
    timeout=20.0,
    interval=5.0,
    retries=5,
    restart=True            # Yeniden başlat
)
```

### Durum Sorgulama

```python
# Task bilgisi
task_def = scheduler.get_task("task_adi")

# Tüm task'ları listele
tasks = scheduler.list_tasks()

# Sonuçları al
results = scheduler.get_results("task_adi")

# Özet
summary = scheduler.summary()
```

### Event Sistemi

```python
def on_task_started(task_def):
    print(f"Task başladı: {task_def.name}")

def on_task_success(result):
    print(f"Task başarılı: {result.result}")

scheduler.on("task_started", on_task_started)
scheduler.on("task_success", on_task_success)
```

## CLI Kullanımı

### Tek Task Çalıştırma

```bash
# Inline kod
pyautotask run merhaba "async def merhaba(): return 'Selam'"

# Dosyadan
pyautotask run merhaba --file script.py

# Parametreler
pyautotask run task --priority high --timeout 10 --retries 3
```

### Batch Çalıştırma

```bash
pyautotask batch config.json
pyautotask batch config.yaml --timeout 30
```

**config.json örneği:**
```json
{
  "tasks": [
    {
      "name": "task1",
      "code": "async def task1(): return 1",
      "priority": "high",
      "timeout": 5
    },
    {
      "name": "task2",
      "file": "script2.py",
      "interval": 2.0,
      "max_runs": 10
    }
  ]
}
```

### Task Listeleme

```bash
pyautotask list config.json
```

### Interactive Shell

```bash
pyautotask shell
```

Shell komutları:
- `run <name> <code>` - Task oluştur
- `stop <name>` - Task durdur
- `cont <name>` - Task devam ettir
- `restart <name>` - Task yeniden başlat
- `trigger <name>` - Hemen çalıştır
- `remove <name>` - Task sil
- `config <name> k=v ...` - Konfigürasyon güncelle
- `list` - Task'ları listele
- `results <name>` - Sonuçları göster
- `summary` - Özet göster
- `exit` - Çıkış

## Veri Yapıları

### TaskState Enum

```python
TaskState.PENDING    # Beklemede
TaskState.RUNNING    # Çalışıyor
TaskState.SUCCESS    # Başarılı
TaskState.FAILED     # Başarısız
TaskState.CANCELLED  # İptal edildi
TaskState.RETRYING   # Yeniden deniyor
TaskState.TIMEOUT    # Zaman aşımı
TaskState.STOPPED    # Durduruldu
TaskState.PAUSED     # Duraklatıldı
```

### TaskPriority Enum

```python
TaskPriority.LOW      = 3
TaskPriority.NORMAL   = 2
TaskPriority.HIGH     = 1
TaskPriority.CRITICAL = 0
```

### TaskResult

```python
@dataclass
class TaskResult:
    task_id: str
    name: str
    state: TaskState
    result: Any = None
    error: Optional[Exception] = None
    started_at: float = 0.0
    finished_at: float = 0.0
    attempts: int = 0
    run_index: int = 0
    
    @property
    def duration(self) -> float: ...
    
    @property
    def success(self) -> bool: ...
```

## Global Fonksiyonlar

Varsayılan scheduler üzerinden hızlı erişim:

```python
from py2autotask import (
    task,           # Task oluştur
    config_task,    # Konfigürasyon güncelle
    stop_task,      # Durdur
    cont_task,      # Devam ettir
    restart_task,   # Yeniden başlat
    remove_task,    # Sil
    trigger_task,   # Tetikle
    get_scheduler,  # Scheduler al
)
```

## Gelişmiş Örnekler

### Callback Kullanımı

```python
def on_success(result):
    print(f"✓ {result.name}: {result.result}")

def on_failure(result):
    print(f"✗ {result.name}: {result.error}")

task(
    "api_call",
    "async def api_call(): ...",
    on_success=on_success,
    on_failure=on_failure
)
```

### Namespace Kullanımı

```python
scheduler = TaskScheduler(
    namespace={
        "db": my_database,
        "cache": my_cache
    }
)

task(
    "db_query",
    """
    async def db_query():
        return await db.fetch("SELECT * FROM users")
    """
)
```

### Event Listener

```python
scheduler.on("task_started", lambda td: print(f"Started: {td.name}"))
scheduler.on("task_success", lambda tr: print(f"Success: {tr.result}"))
scheduler.on("task_failed", lambda tr: print(f"Failed: {tr.error}"))
```

## Lisans

MIT

## Yazarlar

7yokki, brt222

## Sürüm

2.0.1
