Update app.py

app.py

@@ -6,140 +6,126 @@ from datetime import datetime
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
+mcp = FastMCP("Jobicy Remote Jobs Agent")
+
+# ✅ Jobicy 官方欄位選項
+JOB_CATEGORIES = [
+    "", "Business & Management", "Content & Editorial", "Customer Service",
+    "Creative & Design", "DevOps & SysAdmin", "Software Engineering",
+    "Finance & Accounting", "HR & Recruiting", "Product & Operations",
+    "Programming", "Sales & Marketing"
+]
+
+JOB_TYPES = [
+    "", "Remote Full Time Jobs", "Remote Part Time Jobs", "Remote Contract Jobs"
+]
+
+COMPANY_INDUSTRIES = [
+    "", "Technology", "Finance & Accounting", "Health, Wellness & Fitness",
+    "Internet & Online Media"
+]
+
+COUNTRY_CHOICES = [
+    "Anywhere", "usa", "canada", "uk", "europe", "latam", "apac"
+]
 
-mcp = FastMCP("Jobicy Canada Remote Jobs Agent")
 
 @mcp.tool(name="search_jobs")
-def search_jobs_tool(query: str = "", location: str = "", limit: int = 20) -> dict:
+def search_jobs_tool(
+    category: str = "",
+    job_type: str = "",
+    industry: str = "",
+    country: str = "",
+    limit: int = 20
+) -> dict:
     """
-    Search for remote jobs using the Jobicy API.
+    Search for remote jobs from the Jobicy API using optional filters.
 
     Args:
-        query (str): Optional job title or keyword to filter results.
-        location (str): Optional country or location (e.g., "canada", "united states").
-                        Use "Anywhere" or leave blank for global search.
+        category (str): Job Category (e.g., "Software Engineering").
+        job_type (str): Job Type (e.g., "Remote Full Time Jobs").
+        industry (str): Company Industry (e.g., "Technology").
+        country (str): Country or region (e.g., "canada", "uk", or "Anywhere").
         limit (int): Maximum number of job results to return (1–50).
 
     Returns:
-        dict: A dictionary with either a list of jobs (under "jobs") or an "error" message.
+        dict: A dictionary containing a list of jobs under the "jobs" key or an error message under "error".
     """
     base_url = "https://jobicy.com/api/v2/remote-jobs"
-    params = {}
-
-    if query.strip():
-        params["tag"] = query.strip()
-    if location.strip() and location.strip().lower() != "anywhere":
-        params["geo"] = location.strip().lower()
-
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-                      "AppleWebKit/537.36 (KHTML, like Gecko) "
-                      "Chrome/126.0.0.0 Safari/537.36"
-    }
-
+    params = {"count": max(1, min(limit, 50))}
+
+    if category:
+        params["industry"] = category.lower().replace(" & ", "-").replace(" ", "-")
+    if job_type:
+        params["jobType"] = job_type.lower().replace(" ", "-")
+    if industry:
+        params["companyIndustry"] = industry.lower().replace(" & ", "-").replace(" ", "-")
+    if country and country.lower() != "anywhere":
+        params["geo"] = country.lower()
+
+    logger.info(f"Requesting Jobicy with params: {params}")
     try:
-        logger.info(f"Requesting Jobicy API with params: {params}")
-        response = requests.get(base_url, params=params, headers=headers, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-
-        jobs_raw = data.get("jobs", [])
-
-        jobs = []
-        for job in jobs_raw:
-            salary_min = job.get("annualSalaryMin")
-            salary_max = job.get("annualSalaryMax")
-            currency = job.get("salaryCurrency", "")
-            if salary_min and salary_min != 0 and salary_max and salary_max != 0:
-                salary_str = f"{salary_min} - {salary_max} {currency}".strip()
-            else:
-                salary_str = "Not specified"
-
-            jobs.append({
-                "title": job.get("jobTitle", "No Title"),
-                "company": job.get("companyName", "Unknown Company"),
-                "location": job.get("jobGeo", "Remote"),
-                "url": job.get("url", "#"),
-                "pubDate": job.get("pubDate", "Unknown Date"),
-                "salary": salary_str
-            })
-
-        def parse_date(job):
-            try:
-                return datetime.fromisoformat(job["pubDate"].replace("Z", "+00:00"))
-            except Exception:
-                return datetime.min
-
-        jobs.sort(key=parse_date, reverse=True)
-        jobs = jobs[:limit]
-
-        logger.info(f"Found {len(jobs)} jobs from Jobicy after sorting.")
-        return {"jobs": jobs}
-
-    except requests.exceptions.HTTPError as http_err:
-        logger.error(f"HTTP error: {http_err}")
-        return {"error": f"HTTP error occurred: {http_err}"}
-    except requests.exceptions.Timeout:
-        logger.error("Request timed out.")
-        return {"error": "Request timed out. Please try again later."}
-    except requests.exceptions.RequestException as req_err:
-        logger.error(f"Request error: {req_err}")
-        return {"error": f"Request error: {req_err}"}
+        resp = requests.get(base_url, params=params, headers={"User-Agent": "Mozilla/5.0"}, timeout=10)
+        resp.raise_for_status()
+        jobs_raw = resp.json().get("jobs", [])
     except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}")
-        return {"error": f"Unexpected error: {str(e)}"}
-
-def search_jobs_ui(query="", location="", limit=10):
-    limit = int(max(1, min(limit, 50)))
-    result = search_jobs_tool(query, location, limit)
-
-    if "error" in result:
-        return f"❌ Error: {result['error']}"
-
-    jobs = result.get("jobs", [])
-    if not jobs:
-        return "No jobs found for your search. Try different keywords or location."
-
-    output = "# Jobicy Remote Job Search Results\n\n"
-    for i, job in enumerate(jobs, 1):
-        try:
-            posted_date = job['pubDate'][:10]
-        except Exception:
-            posted_date = job['pubDate']
-
-        output += (
-            f"### {i}. {job['title']}\n\n"
-            f"Company: {job['company']}\n\n"
-            f"Location: {job['location']}\n\n"
-            f"Salary: {job['salary']}\n\n"
-            f"Posted On: {posted_date}\n\n"
-            f"[Apply Here]({job['url']})\n\n"
-            "---\n\n"
+        return {"error": f"Fetch error: {e}"}
+
+    def format_job(j):
+        posted = j.get("pubDate", "")[:10]
+        sal_min = j.get("annualSalaryMin")
+        sal_max = j.get("annualSalaryMax")
+        cur = j.get("salaryCurrency", "")
+        salary = f"{sal_min}–{sal_max} {cur}".strip() if sal_min or sal_max else "Not specified"
+        return {
+            "title": j.get("jobTitle", "No Title"),
+            "company": j.get("companyName", ""),
+            "location": j.get("jobGeo", ""),
+            "url": j.get("url", "#"),
+            "pubDate": posted,
+            "salary": salary
+        }
+
+    sorted_jobs = sorted(jobs_raw, key=lambda x: x.get("pubDate", ""), reverse=True)[:params["count"]]
+    return {"jobs": [format_job(j) for j in sorted_jobs]}
+
+
+def search_jobs_ui(category, job_type, industry, country, limit):
+    """
+    Format and display search results as Markdown for the Gradio interface.
+    """
+    res = search_jobs_tool(category, job_type, industry, country, limit)
+    if "error" in res:
+        return f"❌ {res['error']}"
+    if not res["jobs"]:
+        return "No jobs found."
+    
+    md = "# Remote Jobs Results\n\n"
+    for i, j in enumerate(res["jobs"], 1):
+        md += (
+            f"### {i}. {j['title']}\n\n"
+            f"**Company:** {j['company']}\n"
+            f"**Location:** {j['location']}\n"
+            f"**Salary:** {j['salary']}\n"
+            f"**Posted On:** {j['pubDate']}\n"
+            f"[Apply Here]({j['url']})\n\n---\n\n"
         )
-    return output
-
-country_choices = [
-    "Anywhere",
-    "argentina", "australia", "austria", "bangladesh", "belgium", "brazil", "canada", "chile", "china",
-    "colombia", "czech republic", "denmark", "egypt", "estonia", "finland", "france", "germany", "ghana",
-    "greece", "hong kong", "hungary", "iceland", "india", "indonesia", "ireland", "israel", "italy", "japan",
-    "kenya", "latvia", "lithuania", "malaysia", "mexico", "netherlands", "new zealand", "nigeria", "norway",
-    "pakistan", "philippines", "poland", "portugal", "romania", "russia", "saudi arabia", "serbia", "singapore",
-    "slovakia", "slovenia", "south africa", "south korea", "spain", "sweden", "switzerland", "taiwan", "thailand",
-    "turkey", "ukraine", "united arab emirates", "united kingdom", "united states", "vietnam"
-]
+    return md
 
 
+# 🎨 Gradio UI Components
 app = gr.Interface(
     fn=search_jobs_ui,
     inputs=[
-        gr.Textbox(label="Job Title / Keyword (optional)", placeholder="e.g., Software Engineer"),
-        gr.Dropdown(label="Country (optional)", choices=country_choices, value="Anywhere", interactive=True),
-        gr.Slider(minimum=1, maximum=200, value=20, step=1, label="Number of Results"),
+        gr.Dropdown(label="Job Category (optional)", choices=JOB_CATEGORIES, value=""),
+        gr.Dropdown(label="Job Type (optional)", choices=JOB_TYPES, value=""),
+        gr.Dropdown(label="Company Industry (optional)", choices=COMPANY_INDUSTRIES, value=""),
+        gr.Dropdown(label="Country / Region (optional)", choices=COUNTRY_CHOICES, value="Anywhere"),
+        gr.Slider(minimum=1, maximum=50, value=20, step=1, label="Number of Results"),
     ],
     outputs=gr.Markdown(),
     title="Jobicy Remote Job Search",
-    description="Search remote jobs by optional job title and country, sorted by most recent postings.",
+    description="Search remote jobs using filters from Jobicy: job category, job type, company industry, and region.",
     theme="huggingface"
 )