esdd-client 0.1.0__tar.gz

esdd_client-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: esdd-client
+Version: 0.1.0
+Requires-Dist: httpx>=0.25.1
+Requires-Dist: click>=8.1.7
+Requires-Dist: python-dotenv==1.2.1
+Requires-Dist: keyring>=25.2.0

esdd_client-0.1.0/README.md

@@ -0,0 +1,79 @@
+# ESDD Client 
+
+## installation
+At first, install requirements:
+```
+pip3 install -e .
+```
+Usage:
+```
+esdd <arguments>
+```
+
+## Basic commands 
+
+### Authentication via Github 
+``` bash
+# Get authorization URL
+esdd auth github
+
+# Copy URL to browser, authorize, get code
+
+# Exchange code for token
+esdd auth token github <your_code>
+
+# set token 
+esdd auth set-token <token>
+
+# Check token
+esdd auth info
+```
+### Working with tasks 
+``` bash
+# Create task
+esdd task create --question "Annotate dataset" --bid 50
+
+# List tasks
+esdd task list
+esdd task list --status pending --limit 5
+
+# Get task details
+esdd task get 123
+
+# Assign to user
+esdd task assign 123 456
+
+# Start task
+esdd task start 123
+
+# Finalize with data
+esdd task update 123 --json_data '{"result": "completed"}'
+esdd task finalize 123
+
+# Approve/Reject
+esdd task approve 123
+esdd task reject 123
+```
+
+### Complete workflow example
+``` bash
+# 1. Login as admin
+esdd auth set-token <admin_jwt>
+
+# 2. Create and assign task
+esdd task create --question "Validate data" --assign-to 789 --bid 100
+
+# 3. Login as executor
+esdd auth logout
+esdd auth set-token <executor_jwt>
+
+# 4. Execute task
+esdd task list
+esdd task start <task_id>
+esdd task finalize <task_id>
+
+# 5. Return as admin
+esdd auth logout
+esdd auth set-token <admin_jwt>
+esdd  task approve <task_id>
+```

esdd_client-0.1.0/app/src/application/services/auth_service.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+from app.src.infrastructure.repositories.git_oauth_repository import GitOAuthRepository
+from app.src.infrastructure.repositories.mpds_oauth_repository import (
+    MPDSOAuthRepository,
+)
+from app.src.infrastructure.repositories.task_repository_impl import TaskRepositoryImpl
+
+
+class AuthService:
+    def __init__(
+        self,
+        git_repo: Optional[GitOAuthRepository] = None,
+        mpds_repo: Optional[MPDSOAuthRepository] = None,
+        task_repo: Optional[TaskRepositoryImpl] = None,
+        api_url: Optional[str] = None,
+    ) -> None:
+        self.api_url = api_url or "http://localhost:8000"
+        self.git = git_repo or GitOAuthRepository(api_url=self.api_url)
+        self.mpds = mpds_repo or MPDSOAuthRepository(api_url=self.api_url)
+        self.task_repo = task_repo
+        self._current_token: Optional[str] = None
+        self._current_user_id: Optional[int] = None
+
+    def set_token(self, token: str, user_id: Optional[int] = None) -> None:
+        self._current_token = token
+        self._current_user_id = user_id
+        if self.task_repo:
+            self.task_repo.set_token(token)
+
+    def get_current_token(self) -> Optional[str]:
+        return self._current_token
+
+    def get_current_user_id(self) -> Optional[int]:
+        return self._current_user_id
+
+    def get_auth_url(
+        self, provider: str = "github", redirect_url: Optional[str] = None
+    ) -> str:
+        if provider == "github":
+            return self.git.generate_auth_url(redirect_url)
+        elif provider == "mpds":
+            return self.mpds.generate_auth_url(redirect_url)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+    async def get_task_repository(self) -> TaskRepositoryImpl:
+        if not self._current_token:
+            raise ValueError("No token available. Please authenticate first.")
+
+        if not self.task_repo:
+            self.task_repo = TaskRepositoryImpl(
+                api_url=self.api_url, token=self._current_token
+            )
+
+        return self.task_repo
+
+    def clear_auth(self) -> None:
+        self._current_token = None
+        self._current_user_id = None
+        if self.task_repo:
+            self.task_repo.set_token(None)

esdd_client-0.1.0/app/src/application/services/task_service.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List
+
+from app.src.domain.repositories.task_repository import TaskRepository
+
+
+class TaskService:
+    def __init__(self, task_repository: TaskRepository):
+        self.task_repository = task_repository
+
+    async def create_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        return await self.task_repository.create_task(task_data)
+
+    async def get_tasks(
+        self,
+        page: int,
+        per_page: int,
+    ) -> List[Dict[str, Any]]:
+        return await self.task_repository.get_tasks(page, per_page)
+
+    async def update_task(
+        self, task_id: int, task_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self.task_repository.update_task(task_id, task_data)
+
+    async def get_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.get_task(task_id)
+
+    async def delete_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.delete_task(task_id)
+
+    async def assign_task(self, task_id: int, user_id: int) -> Dict[str, Any]:
+        return await self.task_repository.assign_task(task_id, user_id)
+
+    async def start_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.start_task(task_id)
+
+    async def finalize_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.finalize_task(task_id)
+
+    async def approve_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.approve_task(task_id)
+
+    async def reject_task(self, task_id: int) -> Dict[str, Any]:
+        return await self.task_repository.reject_task(task_id)

esdd_client-0.1.0/app/src/domain/repositories/auth_repository.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+
+class AuthRepository(ABC):
+    @abstractmethod
+    def generate_auth_url(self, *args, **kwargs) -> str:
+        """Generate authentication URL"""
+        pass
+
+    @abstractmethod
+    def get_token(self, *args, **kwargs) -> str:
+        """Get authentication token"""
+        pass

esdd_client-0.1.0/app/src/domain/repositories/task_repository.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class TaskRepository(ABC):
+    @abstractmethod
+    async def create_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new task"""
+        pass
+
+    @abstractmethod
+    async def get_tasks(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        status: Optional[str] = None,
+        assignee_id: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """Get list of tasks with optional filtering"""
+        pass
+
+    @abstractmethod
+    async def update_task(
+        self, task_id: int, task_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update an existing task"""
+        pass
+
+    @abstractmethod
+    async def get_task(self, task_id: int) -> Dict[str, Any]:
+        """Get detailed information about a specific task"""
+        pass
+
+    @abstractmethod
+    async def delete_task(self, task_id: int) -> Dict[str, Any]:
+        """Delete a task"""
+        pass
+
+    @abstractmethod
+    async def assign_task(self, task_id: int, user_id: int) -> Dict[str, Any]:
+        """Assign a task to a user"""
+        pass
+
+    @abstractmethod
+    async def start_task(self, task_id: int) -> Dict[str, Any]:
+        """Mark task as started"""
+        pass
+
+    @abstractmethod
+    async def finalize_task(self, task_id: int) -> Dict[str, Any]:
+        """Mark task as finalized/completed"""
+        pass
+
+    @abstractmethod
+    async def approve_task(self, task_id: int) -> Dict[str, Any]:
+        """Approve a completed task"""
+        pass
+
+    @abstractmethod
+    async def reject_task(self, task_id: int) -> Dict[str, Any]:
+        """Reject a completed task"""
+        pass

esdd_client-0.1.0/app/src/infrastructure/repositories/git_oauth_repository.py

@@ -0,0 +1,35 @@
+import os
+from typing import Dict
+from urllib.parse import urlencode
+
+import httpx
+
+from app.src.domain.repositories.auth_repository import AuthRepository
+
+
+class GitOAuthRepository(AuthRepository):
+    def __init__(self, api_url: str = None):
+        self.api_url = api_url or f"{os.getenv('API_URL').rstrip('/')}/api/v1"
+
+    def generate_auth_url(self, redirect_url: str = None) -> str:
+        params = {}
+        if redirect_url:
+            params["redirect"] = redirect_url
+        query_string = f"?{urlencode(params)}" if params else ""
+        return f"{self.api_url}/auth/github{query_string}"
+
+    async def get_token(
+        self, authorization_code: str, redirect_uri: str = None
+    ) -> Dict:
+        base_url = os.getenv("API_URL").rstrip("/")
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self.api_url}/auth/exchange",
+                json={
+                    "provider": "github",
+                    "code": authorization_code,
+                    "redirect_uri": redirect_uri or f"{base_url}/auth/callback/github",
+                },
+            )
+            response.raise_for_status()
+            return response.json()

esdd_client-0.1.0/app/src/infrastructure/repositories/mpds_oauth_repository.py

@@ -0,0 +1,38 @@
+import os
+from typing import Dict
+from urllib.parse import urlencode
+
+import httpx
+
+
+class MPDSOAuthRepository:
+    def __init__(self, api_url: str = None):
+        self.api_url = (
+            api_url or f"{os.getenv('API_URL', 'http://localhost:8000').rstrip('/')}/api/v1"
+        )
+
+    def generate_auth_url(self, redirect_url: str = None) -> str:
+        params = {}
+        if redirect_url:
+            params["redirect"] = redirect_url
+        query_string = f"?{urlencode(params)}" if params else ""
+        return f"{self.api_url}/auth/mpds{query_string}"
+
+    async def get_token(
+        self, authorization_code: str, redirect_uri: str = None
+    ) -> Dict:
+        base_url = os.getenv("BASE_URL", "http://localhost:8000")
+        actual_redirect_uri = redirect_uri or f"{base_url}/auth/callback/mpds"
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self.api_url}/auth/exchange",
+                json={
+                    "provider": "mpds",
+                    "code": authorization_code,
+                    "redirect_uri": actual_redirect_uri,
+                },
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            return response.json()

esdd_client-0.1.0/app/src/infrastructure/repositories/task_repository_impl.py

@@ -0,0 +1,130 @@
+import os
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+
+class TaskRepositoryImpl:
+    def __init__(
+        self, api_url: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        self.api_url = api_url or os.getenv("API_URL", "http://localhost:8000")
+        if self.api_url:
+            self.api_url = f"{self.api_url.rstrip('/')}/api/v1"
+        self.token = token
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def set_token(self, token: str) -> None:
+        self.token = token
+
+    async def create_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self.api_url}/tasks/",
+                json=task_data,
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def get_tasks(
+        self,
+        page: int,
+        per_page: int,
+        # status: Optional[str] = None,
+        # assignee_id: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        params = {
+            "page": page,
+            "per_page": per_page,
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{self.api_url}/tasks/",
+                params=params,
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            data = response.json()
+            return data.get("items", [])
+
+    async def get_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{self.api_url}/tasks/{task_id}/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def update_task(
+        self, task_id: int, task_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/",
+                json=task_data,
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def delete_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.delete(
+                f"{self.api_url}/tasks/{task_id}/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def assign_task(self, task_id: int, user_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/assign/{user_id}/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def start_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/start/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def finalize_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/finalize/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def approve_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/approve/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()
+
+    async def reject_task(self, task_id: int) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.api_url}/tasks/{task_id}/reject/",
+                headers=self._get_headers(),
+                timeout=30.0,
+            )
+            return response.json()

esdd_client-0.1.0/app/src/presentation/cli.py

@@ -0,0 +1,22 @@
+from dotenv import load_dotenv
+import click
+
+load_dotenv(".config")
+
+
+@click.group()
+def cli():
+    """Global CLI Group"""
+    pass
+
+
+import app.src.presentation.routers.auth
+import app.src.presentation.routers.task
+
+
+def main():
+    cli(prog_name="esdd")
+
+
+if __name__ == "__main__":
+    main()

esdd_client-0.1.0/app/src/presentation/routers/auth.py

@@ -0,0 +1,101 @@
+import datetime
+import json
+
+import click
+import jwt
+
+from app.src.infrastructure.repositories.git_oauth_repository import GitOAuthRepository
+from app.src.infrastructure.repositories.mpds_oauth_repository import (
+    MPDSOAuthRepository,
+)
+from app.src.presentation.cli import cli
+from app.src.presentation.utils import TokenManager
+
+
+@cli.group()
+def auth():
+    """Authentication commands"""
+    pass
+
+
+@auth.command()
+@click.option("--redirect", help="Redirect URL")
+def github(redirect):
+    """GitHub authentication"""
+    git_repo = GitOAuthRepository()
+    url = git_repo.generate_auth_url(redirect)
+    click.echo("GitHub Auth URL:")
+    click.echo(url)
+
+
+@auth.command()
+@click.option("--redirect", help="Redirect URL")
+def mpds(redirect):
+    """MPDS authentication"""
+    mpds_repo = MPDSOAuthRepository()
+    url = mpds_repo.generate_auth_url(redirect)
+    click.echo("MPDS Auth URL:")
+    click.echo(url)
+
+
+@auth.command()
+@click.argument("jwt_token")
+def set_token(jwt_token):
+    """Set JWT token directly"""
+    try:
+        payload = jwt.decode(jwt_token, options={"verify_signature": False})
+        user_id = int(payload.get("sub", 0))
+        token_data = {
+            "access_token": jwt_token,
+            "token_type": "bearer",
+            "user_id": user_id,
+            "expires_in": 604800,
+            "payload": payload,
+        }
+        TokenManager.save_token(token_data)
+        click.echo("Token saved")
+        click.echo(json.dumps({"user_id": user_id, "token_type": "bearer"}, indent=2))
+    except Exception as e:
+        click.echo(f"Error: {str(e)}")
+
+
+@auth.command()
+def info():
+    """Show token information"""
+    token_data = TokenManager.get_token_info()
+    if token_data:
+        click.echo("Token Information:")
+        click.echo(json.dumps(token_data, indent=2, default=str))
+    else:
+        click.echo("No token found")
+
+
+@auth.command()
+def decode():
+    """Decode JWT token"""
+    token = TokenManager.get_token()
+    if not token:
+        click.echo("No token found")
+        return
+    try:
+        payload = jwt.decode(token, options={"verify_signature": False})
+        click.echo("JWT Payload:")
+        click.echo(json.dumps(payload, indent=2))
+        user_id = payload.get("sub")
+        if user_id:
+            click.echo(f"\nUser ID: {user_id}")
+        exp = payload.get("exp")
+        if exp:
+            exp_time = datetime.datetime.fromtimestamp(exp)
+            click.echo(f"Expires: {exp_time}")
+    except Exception as e:
+        click.echo(f"Error decoding token: {str(e)}")
+
+
+@auth.command()
+def logout():
+    """Logout (clear token)"""
+    if TokenManager.clear_token():
+        click.echo("Logged out")
+    else:
+        click.echo("Logout failed")

esdd_client-0.1.0/app/src/presentation/routers/task.py

@@ -0,0 +1,232 @@
+import json
+import os
+
+import click
+
+from app.src.application.services.auth_service import AuthService
+from app.src.application.services.task_service import TaskService
+from app.src.presentation.cli import cli
+from app.src.presentation.utils import TokenManager, async_command, require_auth
+
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+
+@cli.group()
+def task():
+    """Task management commands"""
+    pass
+
+
+@task.command()
+@click.option("--page", default=1, help="Number of pages")
+@click.option(
+    "--per_page", default=20, help="Maximum number of tasks to return per page"
+)
+@require_auth
+@async_command
+async def list(page, per_page):
+    """List tasks"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    tasks = await task_service.get_tasks(page=page, per_page=per_page)
+
+    click.echo(f"Found {len(tasks)} tasks")
+    for task in tasks:
+        task_id = task.get("task_id")
+        status_val = task.get("status")
+        question = task.get("question", "")[:60]
+        assignee_val = task.get("assigned_to", "Unassigned")
+        created_by = task.get("created_by")
+        click.echo(f"ID: #{task_id}")
+        click.echo(f"  Status: {status_val}")
+        click.echo(f"  Question: {question}")
+        click.echo(f"  Assignee: {assignee_val}")
+        click.echo(f"  Created by: {created_by}")
+        if "bid" in task:
+            click.echo(f"  Bid: {task['bid']}")
+        click.echo()
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def get(task_id):
+    """Get task details"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.get_task(task_id)
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.option("--question", required=True, help="Task question")
+@click.option("--bid", type=int, required=True, help="Bid amount")
+@click.option("--assign-to", type=int, help="Assign to user ID")
+@click.option("--schema", type=int, help="Schema ID")
+@click.option("--crop", type=int, help="Crop ID")
+@require_auth
+@async_command
+async def create(question, bid, assign_to, schema, crop):
+    """Create a new task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    task_data = {"question": question, "bid": bid}
+    if assign_to:
+        task_data["assigned_to"] = assign_to
+        task_data["assign_task"] = True
+    if schema:
+        task_data["schema_id"] = schema
+    if crop:
+        task_data["crop_id"] = crop
+
+    result = await task_service.create_task(task_data)
+    click.echo("Task created")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@click.argument("fields", nargs=-1)
+@require_auth
+@async_command
+async def update(task_id, fields):
+    """Update task fields (field=value format)"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    update_data = {}
+    for field_pair in fields:
+        if "=" in field_pair:
+            key, value = field_pair.split("=", 1)
+            if value.lower() == "true":
+                value = True
+            elif value.lower() == "false":
+                value = False
+            elif value.isdigit():
+                value = int(value)
+            elif key == "json_data":
+                value = json.loads(value)
+            update_data[key] = value
+
+    result = await task_service.update_task(task_id, update_data)
+    click.echo("Task updated")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def delete(task_id):
+    """Delete a task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.delete_task(task_id)
+    click.echo("Task deleted")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@click.argument("user_id", type=int)
+@require_auth
+@async_command
+async def assign(task_id, user_id):
+    """Assign task to user"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.assign_task(task_id, user_id)
+    click.echo("Task assigned")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def start(task_id):
+    """Start working on task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.start_task(task_id)
+    click.echo("Task started")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def finalize(task_id):
+    """Finalize task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.finalize_task(task_id)
+    click.echo("Task finalized")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def approve(task_id):
+    """Approve task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.approve_task(task_id)
+    click.echo("Task approved")
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
+@task.command()
+@click.argument("task_id", type=int)
+@require_auth
+@async_command
+async def reject(task_id):
+    """Reject task"""
+    token = TokenManager.get_token()
+    auth_service = AuthService(api_url=API_URL)
+    auth_service.set_token(token)
+    task_repo = await auth_service.get_task_repository()
+    task_service = TaskService(task_repo)
+
+    result = await task_service.reject_task(task_id)
+    click.echo("Task rejected")
+    click.echo(json.dumps(result, indent=2, default=str))

esdd_client-0.1.0/app/src/presentation/utils.py

@@ -0,0 +1,75 @@
+import asyncio
+import datetime
+import json
+from functools import wraps
+from typing import Any, Dict, Optional
+
+import click
+import keyring
+
+KEYRING_SERVICE_NAME = "esdd-cli"
+
+
+def async_command(f):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        return asyncio.run(f(*args, **kwargs))
+
+    return wrapper
+
+
+class TokenManager:
+    @staticmethod
+    def get_token() -> Optional[str]:
+        token_json = keyring.get_password(KEYRING_SERVICE_NAME, "access_token")
+        if token_json:
+            try:
+                token_data = json.loads(token_json)
+                return token_data.get("access_token")
+            except json.JSONDecodeError:
+                return None
+        return None
+
+    @staticmethod
+    def save_token(token_data: Dict[str, Any]) -> None:
+        token_data["created_at"] = datetime.datetime.now().isoformat()
+        token_json = json.dumps(token_data)
+        keyring.set_password(KEYRING_SERVICE_NAME, "access_token", token_json)
+
+    @staticmethod
+    def clear_token() -> bool:
+        try:
+            keyring.delete_password(KEYRING_SERVICE_NAME, "access_token")
+            return True
+        except keyring.errors.PasswordDeleteError:
+            return False
+
+    @staticmethod
+    def get_token_info() -> Optional[Dict[str, Any]]:
+        token_json = keyring.get_password(KEYRING_SERVICE_NAME, "access_token")
+        if token_json:
+            try:
+                token_data = json.loads(token_json)
+                created_at = token_data.get("created_at")
+                expires_in = token_data.get("expires_in", 0)
+                if created_at and expires_in:
+                    created = datetime.datetime.fromisoformat(created_at)
+                    expires_at = created + datetime.timedelta(seconds=expires_in)
+                    now = datetime.datetime.now()
+                    token_data["is_valid"] = now < expires_at
+                    token_data["expires_at"] = expires_at.isoformat()
+                return token_data
+            except (json.JSONDecodeError, KeyError):
+                return None
+        return None
+
+
+def require_auth(f):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        if not TokenManager.get_token():
+            click.echo("Not authenticated. Use 'esdd auth' commands first.")
+            return
+        return f(*args, **kwargs)
+
+    return wrapper

esdd_client-0.1.0/esdd_client.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: esdd-client
+Version: 0.1.0
+Requires-Dist: httpx>=0.25.1
+Requires-Dist: click>=8.1.7
+Requires-Dist: python-dotenv==1.2.1
+Requires-Dist: keyring>=25.2.0

esdd_client-0.1.0/esdd_client.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+app/src/application/__init__.py
+app/src/application/services/auth_service.py
+app/src/application/services/task_service.py
+app/src/domain/__init__.py
+app/src/domain/repositories/auth_repository.py
+app/src/domain/repositories/task_repository.py
+app/src/infrastructure/__init__.py
+app/src/infrastructure/repositories/git_oauth_repository.py
+app/src/infrastructure/repositories/mpds_oauth_repository.py
+app/src/infrastructure/repositories/task_repository_impl.py
+app/src/presentation/__init__.py
+app/src/presentation/cli.py
+app/src/presentation/utils.py
+app/src/presentation/routers/auth.py
+app/src/presentation/routers/task.py
+esdd_client.egg-info/PKG-INFO
+esdd_client.egg-info/SOURCES.txt
+esdd_client.egg-info/dependency_links.txt
+esdd_client.egg-info/entry_points.txt
+esdd_client.egg-info/requires.txt
+esdd_client.egg-info/top_level.txt

esdd_client-0.1.0/esdd_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

esdd_client-0.1.0/esdd_client.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+esdd = app.src.presentation.cli:main

esdd_client-0.1.0/esdd_client.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.25.1
+click>=8.1.7
+python-dotenv==1.2.1
+keyring>=25.2.0

esdd_client-0.1.0/esdd_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+app

esdd_client-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "esdd-client"
+version = "0.1.0"
+dependencies = [
+    "httpx>=0.25.1",
+    "click>=8.1.7",
+    "python-dotenv==1.2.1",
+    "keyring>=25.2.0"
+]
+
+[project.scripts]
+esdd = "app.src.presentation.cli:main"
+
+[tool.flake8]
+max-line-length = 100
+
+ignore = ["E402", "F401"]

esdd_client-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+