from pearch.client import AsyncPearchClient
from pearch.schema import V2SearchRequest

QUERY = "Find me engineers in California speaking at least basic english working in software industry with experience at FAANG with 2+ years of experience and at least 500 followers and at least BS degree"

client = AsyncPearchClient()
results = await client.search(V2SearchRequest(query=QUERY))
print(results.model_dump_json()[:1000])

# Or use with context manager for automatic cleanup
async with AsyncPearchClient() as client:
    results = await client.search(V2SearchRequest(query=QUERY))
print(results.model_dump_json()[:1000])

from pearch.client import PearchClient
from pearch.schema import V2SearchRequest

QUERY = "Find me engineers in California speaking at least basic english working in software industry with experience at FAANG with 2+ years of experience and at least 500 followers and at least BS degree"

client = PearchClient()
results = client.search(V2SearchRequest(query=QUERY))

# Or use with context manager for automatic cleanup
with PearchClient() as client:
    results = client.search(V2SearchRequest(query=QUERY))

from pearch.client import PearchClient
from pearch import V2SearchRequest, CustomFilters

with PearchClient() as client:
    # Create structured filters with type hints and validation
    filters = CustomFilters(
        locations=["San Francisco", "New York"],
        industries=["health", "pharma"],
        titles=["software engineer", "data scientist"],
        min_total_experience_years=5,
        max_total_experience_years=15,
        studied_at_top_universities=True,
        has_startup_experience=True,
        degrees=["bachelor", "master"],
        specialization_categories=["Computer Science & IT", "Engineering"],
        min_linkedin_followers=500,
        gender="male"
    )
    
    results = client.search(V2SearchRequest(
        query="senior engineer with ML experience",
        custom_filters=filters,
        limit=20
    ))

results = client.search(V2SearchRequest(
    query="software engineer",
    custom_filters={
        "locations": ["San Francisco"],
        "min_total_experience_years": 3
    }
))

from pearch.client import PearchClient
from pearch.schema import V1UpsertJobsRequest, V1FindMatchingJobsRequest, V1ListJobsRequest, V1DeleteJobsRequest, Job

# Upload or update job listings
with PearchClient() as client:
    response = client.upsert_jobs(V1UpsertJobsRequest(
        jobs=[
            Job(
                job_id="1",
                job_description="software engineer in test for la ai startup",
            )
        ]
    ))
    print(response.uuid)
    print(response.status)
    print(f"Upsert status: {response.model_dump_json()}")

# Find jobs matching a candidate profile  
with PearchClient() as client:
    response = client.find_matching_jobs(V1FindMatchingJobsRequest(
        profile={
            "description": "I'm a Senior Silicon Design Engineer with strong background in computer engineering, hands-on silicon design experience, and deep understanding of the semiconductor industry."
        },
        limit=2,
    ))
    for job in response.jobs:
        print(job.job_id, job.model_dump_json()[:100])

from pearch.client import PearchClient
from pearch.schema import V1ListJobsRequest

# List all jobs in your index
with PearchClient() as client:
    response = client.list_jobs(V1ListJobsRequest(limit=10))
    print(f"Total jobs: {response.total_count}")
    print(f"Returned jobs: {response.returned_count}")
    
    for job in response.jobs:
        print(f"Job ID: {job.job_id}")
        print(f"Description: {job.job_description}")
        print(f"Created: {job.created_at}")
        print("---")

from pearch.client import PearchClient
from pearch.schema import V1DeleteJobsRequest

# Delete specific jobs by their IDs
with PearchClient() as client:
    response = client.delete_jobs(V1DeleteJobsRequest(
        job_ids=["test_job_1", "test_job_2"]
    ))
    print(f"Status: {response.status}")
    print(f"Deleted count: {response.deleted_count}")
    if response.errors:
        print(f"Errors: {response.errors}")

from pearch.client import PearchClient
from pearch.schema import V1ProfileRequest

# Retrieve detailed profile information
with PearchClient() as client:
    request = V1ProfileRequest(
        docid="vslaykovsky", 
        reveal_emails=True,
        with_profile=True
    )
    response = client.get_profile(request)
    print(f"Profile: {response.model_dump_json()[:1000]}")

from openai import OpenAI

client = OpenAI(
    base_url="https://api.pearch.ai/",
    api_key="your-api-key"
)

# Streaming search
stream = client.chat.completions.create(
    model="pearch",
    stream=True,
    messages=[{"role": "user", "content": "software engineers at Google with 10 years of experience"}],
    extra_body={
        "limit": 5,
        "type": "fast"
    }
)

for chunk in stream:
    if chunk.choices and len(chunk.choices) > 0:
        delta = chunk.choices[0].delta
        if delta and delta.content:
            print(delta.content, end="", flush=True)
        if chunk.choices[0].finish_reason is not None:
            print(f"\nFinished: {chunk.choices[0].finish_reason}")

stream = client.chat.completions.create(
    model="pearch",
    stream=True,
    messages=[{"role": "user", "content": "software engineers in California"}],
    extra_body={
        "limit": 10,
        "type": "pro",  # or "fast"
        "stream_profiles": "batch",
        "profiles_batch_size": 5,
        "final_result": True,
        "insights": True,
        "high_freshness": True,
        "reveal_emails": True,
        "reveal_phones": True,
        "filter_out_no_emails": True,
        "filter_out_no_phones": True,
        "profile_scoring": True,
        "strict_filters": False,
        "custom_filters": {}
    }
)

# First request
stream1 = client.chat.completions.create(
    model="pearch",
    stream=True,
    messages=[{"role": "user", "content": "software engineers at Google"}],
    extra_body={"limit": 5, "type": "fast"}
)

# Extract thread_id from final chunk
thread_id = None
for chunk in stream1:
    if chunk.choices and chunk.choices[0].finish_reason is not None:
        # Extract thread_id from chunk summary if available
        break

# Continue with same thread
stream2 = client.chat.completions.create(
    model="pearch",
    stream=True,
    messages=[{"role": "user", "content": "who are at least 30 years old"}],
    extra_body={"limit": 5, "thread_id": thread_id, "type": "fast"}
)