from kubiya_workflow_sdk import Client

client = Client(
    api_key: str = None,
    api_url: str = None,
    org_name: str = None,
    timeout: int = 30,
    retry_count: int = 3,
    verify_ssl: bool = True,
    proxy: str = None
)

result = client.execute_workflow(
    workflow=my_workflow,
    params={"env": "production"},
    stream=True,
    runner="my-custom-runner"  # Optional: specify a runner created via Kubiya platform
)

workflows = client.list_workflows()
for wf in workflows:
    print(f"{wf.name}: {wf.description}")

workflow = client.get_workflow("data-pipeline")

if client.test_connection():
    print("Connected successfully!")

from kubiya_workflow_sdk import Workflow

workflow = Workflow(
    name: str,
    description: str = None,
    version: str = "1.0.0",
    steps: List[Step] = None,
    parameters: Dict[str, Parameter] = None,
    runner: str = "kubiya-hosted",
    tags: List[str] = None,
    metadata: Dict[str, Any] = None
)

workflow.add_step(
    Step(name="process", image="python:3.11", command="process.py")
)

workflow_dict = workflow.to_dict()

yaml_string = workflow.to_yaml()
print(yaml_string)

errors = workflow.validate()
if errors:
    print(f"Validation errors: {errors}")

result = workflow.execute(
    client=client,
    params={"env": "staging"}
)

from kubiya_workflow_sdk import Step

step = Step(
    name: str,
    image: str = None,
    command: str = None,
    script: str = None,
    env: Dict[str, str] = None,
    volumes: Dict[str, str] = None,
    resources: Dict[str, Any] = None,
    depends: List[str] = None,
    retry: RetryPolicy = None,
    timeout: str = "5m",
    when: str = None,
    outputs: Dict[str, str] = None
)

from kubiya_workflow_sdk.dsl import workflow

@workflow(
    name: str = None,
    description: str = None,
    runner: str = "kubiya-hosted",
    version: str = "1.0.0"
)
def my_workflow():
    # Workflow logic
    pass

result = step.shell(
    "echo 'Hello World'",
    name="greeting",
    image="alpine:latest"
)

output = step.python(
    """
    import pandas as pd
    df = pd.read_csv('data.csv')
    print(df.describe())
    """,
    name="analyze",
    packages=["pandas", "numpy"]
)

step.container(
    image="nginx:alpine",
    name="webserver",
    ports={"80": "8080"},
    health_check={
        "test": ["CMD", "curl", "-f", "http://localhost/"],
        "interval": "30s"
    }
)

analysis = step.inline_agent(
    message="Analyze these logs: ${logs}",
    runners=["kubiya-hosted"],
    llm_model="gpt-4",
    tools=[{
        "name": "parse-logs",
        "type": "docker",
        "image": "log-parser:latest"
    }]
)

from kubiya_workflow_sdk.providers import get_provider

provider = get_provider(
    "adk",
    api_key="...",
    model="gemini-1.5-pro"
)

from kubiya_workflow_sdk.providers import BaseProvider

class CustomProvider(BaseProvider):
    async def compose(self, task: str, mode: str = "plan", **kwargs):
        # Implementation
        pass
    
    async def execute_workflow(self, workflow, **kwargs):
        # Implementation
        pass

@dataclass
class StreamEvent:
    type: str  # "step.started", "log", "step.completed", etc.
    timestamp: float
    step_name: str = None
    data: Dict[str, Any] = None
    error: str = None

from kubiya_workflow_sdk.errors import KubiyaError

try:
    client.execute_workflow(workflow)
except KubiyaError as e:
    print(f"Kubiya error: {e}")

from kubiya_workflow_sdk.errors import AuthenticationError

try:
    client = Client(api_key="invalid")
except AuthenticationError as e:
    print("Invalid API key")

from kubiya_workflow_sdk.errors import ValidationError

try:
    workflow.validate()
except ValidationError as e:
    print(f"Validation failed: {e.errors}")

from kubiya_workflow_sdk.errors import ExecutionError

try:
    result = workflow.execute()
except ExecutionError as e:
    print(f"Execution failed at step: {e.step_name}")

from kubiya_workflow_sdk.utils import load_workflow

workflow = load_workflow("workflows/pipeline.yaml")

from kubiya_workflow_sdk.utils import save_workflow

save_workflow(workflow, "workflows/pipeline.yaml")

from kubiya_workflow_sdk.utils import merge_workflows

combined = merge_workflows(etl_workflow, ml_workflow)

from kubiya_workflow_sdk.types import RetryPolicy

retry = RetryPolicy(
    max_attempts: int = 3,
    backoff: str = "exponential",  # "constant", "linear", "exponential"
    initial_delay: str = "1s",
    max_delay: str = "5m"
)

from kubiya_workflow_sdk.types import ResourceSpec

resources = ResourceSpec(
    requests={"cpu": "1", "memory": "2Gi"},
    limits={"cpu": "2", "memory": "4Gi"},
    gpus=1  # Optional GPU request
)

from kubiya_workflow_sdk.types import Parameter

param = Parameter(
    name="environment",
    type="string",
    default="staging",
    choices=["dev", "staging", "production"],
    required=False,
    description="Target environment"
)

from kubiya_workflow_sdk import Client, Workflow, Step

# Create workflow
workflow = Workflow(
    name="hello-world",
    steps=[
        Step(name="greet", image="alpine", command="echo 'Hello!'")
    ]
)

# Execute
client = Client()
result = client.execute_workflow(workflow)
print(result.output)

# Stream execution events
for event in client.execute_workflow(workflow, stream=True):
    if event.type == "log":
        print(event.data["message"])
    elif event.type == "step.completed":
        print(f"Step {event.step_name} completed")

from kubiya_workflow_sdk.errors import ExecutionError, StepError

try:
    result = workflow.execute()
except StepError as e:
    print(f"Step {e.step_name} failed: {e.message}")
    # Handle step failure
except ExecutionError as e:
    print(f"Workflow failed: {e}")
    # Handle workflow failure