benchmark stringclasses 1
value | task_name stringlengths 19 96 | task_seed int64 0 2 | task_config stringlengths 97 1.34k | goal stringlengths 23 1.12k | start_url stringclasses 1
value | validation stringclasses 1
value |
|---|---|---|---|---|---|---|
erpnext | erpnext.tag_sales_invoice | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabSales Invoice` WHERE name=\"ACC-SINV-2025-00005\" and _user_tags LIKE \"%,urgent%,quick%\"", "count": 1} | Find a sales invoice ACC-SINV-2025-00005 and add the following tags to it: urgent, quick | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabStock Entry` AS se INNER JOIN `tabStock Entry Detail` AS sed ON se.name=sed.parent WHERE se.company=\"ServiceNow\" AND se.stock_entry_type=\"Manufacture\" AND sed.item_code=\"SKU0015\" AND sed.qty=\"20\" AND sed.s_warehouse=\"Guardians - SN\"", "count": 1} | create stock entry with ServiceNow for company, Manufacture for stock entry type, SKU0015 for item code, 20 for quantity, and Guardians - SN for source warehouse | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabStock Entry` AS se INNER JOIN `tabStock Entry Detail` AS sed ON se.name=sed.parent WHERE se.company=\"ServiceNow\" AND se.stock_entry_type=\"Material Issue\" AND sed.item_code=\"SKU0017\" AND sed.qty=\"50\" AND sed.s_warehouse=\"Teen Kick - SN\"", "count": 1} | create stock entry with ServiceNow for company, Material Issue for stock entry type, SKU0017 for item code, 50 for quantity, and Teen Kick - SN for source warehouse | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_entry_with_letterhead | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabStock Entry` AS se INNER JOIN `tabStock Entry Detail` AS sed ON se.name=sed.parent INNER JOIN `tabLetter Head` AS lh ON se.letter_head=lh.letter_head_name WHERE se.company=\"ServiceNow\" AND se.stock_entry_type=\"Manufacture\" AND se.letter_head=\"Wendigo Ltd.\" AND lh... | create stock entry with ServiceNow for company, Manufacture for stock entry type, SKU0015 for item code, 20 for quantity, Finished Goods - SN for source warehouse, Stores - SN for target warehouse, and Wendigo Ltd. for letter head name with 3.0 for image height and 2.0 for image width | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_entry_with_letterhead | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabStock Entry` AS se INNER JOIN `tabStock Entry Detail` AS sed ON se.name=sed.parent INNER JOIN `tabLetter Head` AS lh ON se.letter_head=lh.letter_head_name WHERE se.company=\"ServiceNow\" AND se.stock_entry_type=\"Material Issue\" AND se.letter_head=\"rere\" AND lh.imag... | create stock entry with ServiceNow for company, Material Issue for stock entry type, SKU0017 for item code, 50 for quantity, The Dream Vault - SN for source warehouse, Work in Progress - SN for target warehouse, and rere for letter head name with 5.0 for image height and 4.0 for image width | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_id_group | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU019\" AND item_group=\"Products\"", "count": 1} | create stock item with SKU019 for item code and Products for item group | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_id_group | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU050\" AND item_group=\"Consumable\"", "count": 1} | create stock item with SKU050 for item code and Consumable for item group | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_id_group | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU030\" AND item_group=\"Raw Material\"", "count": 1} | create stock item with SKU030 for item code and Raw Material for item group | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU090\" AND item_group=\"Products\" AND item_name=\"Flower Bouquet\" AND description LIKE \"%artificial flower bouquet that includes lilies, roses, carnations, tulips, and hyacinths%\" AND delivered_by_supplier=1", "count": 1} | create stock item with SKU090 for the item code, Flower Bouquet for the item name, Products for the item group, 'artificial flower bouquet that includes lilies, roses, carnations, tulips, and hyacinths' for description, and check the box 'Delivered by Supplier (Drop Ship)' | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU091\" AND item_group=\"Consumable\" AND item_name=\"Cookie\" AND description LIKE \"%homemade cookie, options include chocolate chip, snickerdoodle, sugar, oatmeal raisin%\" AND delivered_by_supplier=1", "count": 1} | create stock item with SKU091 for the item code, Cookie for the item name, Consumable for the item group, 'homemade cookie, options include chocolate chip, snickerdoodle, sugar, oatmeal raisin' for description, and check the box 'Delivered by Supplier (Drop Ship)' | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem WHERE item_code=\"SKU092\" AND item_group=\"Raw Material\" AND item_name=\"Laundry Detergent\" AND description LIKE \"%laundry detergent liquid%\" AND delivered_by_supplier=1", "count": 1} | create stock item with SKU092 for the item code, Laundry Detergent for the item name, Raw Material for the item group, 'laundry detergent liquid' for description, and check the box 'Delivered by Supplier (Drop Ship)' | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description_shelf_life_warranty | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem INNER JOIN `tabItem Reorder` ON item_code=parent WHERE item_code=\"SKU022\" AND item_group=\"Consumable\" AND item_name=\"Gingerbread House Decorating Kit\" AND description LIKE \"%DIY gingerbread house decorating kit containing pre-baked gingerbread pieces, icing ... | Create a stock item with the following criteria: - item code: SKU022 - item name: Gingerbread House Decorating Kit - item group: Consumable - description: DIY gingerbread house decorating kit containing pre-baked gingerbread pieces, icing mix, candies for decoration, and piping bags - shelf life: 365 days - end of life... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description_shelf_life_warranty | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem INNER JOIN `tabItem Reorder` ON item_code=parent WHERE item_code=\"SKU023\" AND item_group=\"Consumable\" AND item_name=\"Box of Candy Canes\" AND description LIKE \"%box of 12 peppermint candy canes%\" AND shelf_life_in_days=\"730\" AND end_of_life=\"2070-11-30\" ... | Create a stock item with the following criteria: - item code: SKU023 - item name: Box of Candy Canes - item group: Consumable - description: box of 12 peppermint candy canes - shelf life: 730 days - end of life: 2070-11-30 - warranty period: 60 days - weight per unit: 0.5 Set up the item to auto-reorder when stock quan... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_stock_item_name_id_group_description_shelf_life_warranty | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabItem INNER JOIN `tabItem Reorder` ON item_code=parent WHERE item_code=\"SKU024\" AND item_group=\"Products\" AND item_name=\"Elf Hat\" AND description LIKE \"%felted elf hat with small bells%\" AND shelf_life_in_days=\"3650\" AND end_of_life=\"2100-12-31\" AND warranty_... | Create a stock item with the following criteria: - item code: SKU024 - item name: Elf Hat - item group: Products - description: felted elf hat with small bells - shelf life: 3650 days - end of life: 2100-12-31 - warranty period: 90 days - weight per unit: 0.01 Set up the item to auto-reorder when stock quantity reaches... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.delete_stock_item | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_code=\"SKU101\"", "count": 0} | delete stock item with ID SKU101 | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.delete_stock_item | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_code=\"SKU100\"", "count": 0} | delete stock item with ID SKU100 | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.disable_stock_item | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_code=\"Bowl\" and disabled=1", "count": 1} | disable stock item Bowl | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.disable_stock_item | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_code=\"Chopsticks\" and disabled=1", "count": 1} | disable stock item Chopsticks | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.edit_stock_item_warranty_weight | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_name=\"wine bottle\" AND warranty_period=\"100\" AND weight_per_unit=\"3.0\"", "count": 1} | edit the warranty period of the stock item wine bottle to 100 days and weight per unit to 3.0 | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.edit_stock_item_warranty_weight | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_name=\"clock\" AND warranty_period=\"365\" AND weight_per_unit=\"10.0\"", "count": 1} | edit the warranty period of the stock item clock to 365 days and weight per unit to 10.0 | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.edit_stock_item_warranty_weight_material_request_type_tag | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_name=\"Router\" AND warranty_period=\"100\" AND weight_per_unit=\"3.0\" AND default_material_request_type=\"Purchase\" AND _user_tags LIKE \"%,priority%\" AND allow_alternative_item=1", "count": 1} | For stock item Router, edit the warranty period to 100 days, weight per unit to 3.0, and default material request type to Purchase, then add the tag "priority" and allow an alternative item | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.edit_stock_item_warranty_weight_material_request_type_tag | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabItem` WHERE item_name=\"Egg Crate\" AND warranty_period=\"365\" AND weight_per_unit=\"10.0\" AND default_material_request_type=\"Material Issue\" AND _user_tags LIKE \"%,asap%\" AND allow_alternative_item=1", "count": 1} | For stock item Egg Crate, edit the warranty period to 365 days, weight per unit to 10.0, and default material request type to Material Issue, then add the tag "asap" and allow an alternative item | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_full_address_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Eustace\" AND middle_name=\"A\" AND last_name=\"Bagge\" AND gender=\"Male\" AND date_of_birth=\"1997-04-19\" AND date_of_joining=\"2024-09-18\" AND cell_number=\"112-111-1131\" AND personal_email=\"eustace.bagge@yahoo.com\" AND company_emai... | Create a record for an employee named Eustace A Bagge. Enter Male for gender, 1997-04-19 for date of birth, 2024-09-18 for date of joining, and 112-111-1131 for their phone number. Enter their personal and company email addresses: eustace.bagge@servicenow.com and eustace.bagge@yahoo.com, respectively and choose Company... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_full_address_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Muriel\" AND middle_name=\"A\" AND last_name=\"Bagge\" AND gender=\"Female\" AND date_of_birth=\"1975-05-21\" AND date_of_joining=\"2024-04-22\" AND cell_number=\"122-121-1512\" AND personal_email=\"muriel.bagge@hotmail.com\" AND company_em... | Create a record for an employee named Muriel A Bagge. Enter Female for gender, 1975-05-21 for date of birth, 2024-04-22 for date of joining, and 122-121-1512 for their phone number. Enter their personal and company email addresses: muriel.bagge@servicenow.com and muriel.bagge@hotmail.com, respectively and choose Person... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_full_address_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Courage\" AND middle_name=\"TheCowardly\" AND last_name=\"Dog\" AND gender=\"Male\" AND date_of_birth=\"1971-05-22\" AND date_of_joining=\"2024-08-22\" AND cell_number=\"000-000-1111\" AND personal_email=\"courage.dog@gmail.com\" AND compan... | Create a record for an employee named Courage TheCowardly Dog. Enter Male for gender, 1971-05-22 for date of birth, 2024-08-22 for date of joining, and 000-000-1111 for their phone number. Enter their personal and company email addresses: courage.dog@servicenow.com and courage.dog@gmail.com, respectively and choose Per... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_join_date_salary_phone | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Chris\" AND middle_name=\"A\" AND last_name=\"Redfield\" AND gender=\"Male\" AND date_of_birth=\"1998-03-19\" AND date_of_joining=\"2023-04-18\" AND ctc=\"120000.0\" AND salary_currency=\"USD\" AND cell_number=\"111-111-1131\"", "count": 1} | create employee record with the full name Chris A Redfield, Male for gender, 1998-03-19 for date of birth, 2023-04-18 for date of joining, 111-111-1131 for mobile phone number, 120000.0 for salary, USD for salary currency | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_join_date_salary_phone | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Renato\" AND middle_name=\"Lee\" AND last_name=\"Lyra\" AND gender=\"Male\" AND date_of_birth=\"1973-04-21\" AND date_of_joining=\"2010-05-22\" AND ctc=\"80000.0\" AND salary_currency=\"AUD\" AND cell_number=\"120-121-1512\"", "count": 1} | create employee record with the full name Renato Lee Lyra, Male for gender, 1973-04-21 for date of birth, 2010-05-22 for date of joining, 120-121-1512 for mobile phone number, 80000.0 for salary, AUD for salary currency | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_join_date_salary_phone | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Julio\" AND middle_name=\"R\" AND last_name=\"Allegro\" AND gender=\"Transgender\" AND date_of_birth=\"1970-04-22\" AND date_of_joining=\"2024-08-22\" AND ctc=\"120500.0\" AND salary_currency=\"CNY\" AND cell_number=\"000-000-0001\"", "coun... | create employee record with the full name Julio R Allegro, Transgender for gender, 1970-04-22 for date of birth, 2024-08-22 for date of joining, 000-000-0001 for mobile phone number, 120500.0 for salary, CNY for salary currency | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_status_join_date | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Albert\" AND middle_name=\"James\" AND last_name=\"Wesker\" AND gender=\"Prefer not to say\" AND date_of_birth=\"1998-11-11\" AND status=\"Active\" AND date_of_joining=\"2023-08-08\"", "count": 1} | create employee record with the full name Albert James Wesker, Prefer not to say for gender, 1998-11-11 for birth date, Active for status, and 2023-08-08 for date of joining | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_status_join_date | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Leon\" AND middle_name=\"S\" AND last_name=\"Kennedy\" AND gender=\"Genderqueer\" AND date_of_birth=\"1973-11-11\" AND status=\"Inactive\" AND date_of_joining=\"2017-10-15\"", "count": 1} | create employee record with the full name Leon S Kennedy, Genderqueer for gender, 1973-11-11 for birth date, Inactive for status, and 2017-10-15 for date of joining | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_name_gender_dob_status_join_date | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Ethan\" AND middle_name=\"R\" AND last_name=\"Winters\" AND gender=\"Male\" AND date_of_birth=\"1990-12-14\" AND status=\"Suspended\" AND date_of_joining=\"2023-12-28\"", "count": 1} | create employee record with the full name Ethan R Winters, Male for gender, 1990-12-14 for birth date, Suspended for status, and 2023-12-28 for date of joining | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_with_emergency_contact_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Michael\" AND middle_name=\"Jeffrey\" AND last_name=\"Jordan\" AND gender=\"Male\" AND date_of_birth=\"1963-02-17\" AND date_of_joining=\"2024-08-18\" AND department=\"Long John Silver's - SN\" AND cell_number=\"222-111-1131\" AND person_to... | Create an employee record for the employee named Michael Jeffrey Jordan. Their gender is Male, date of birth is 1963-02-17, date of joining is 2024-08-18, department is Long John Silver's, and they can be reached at 222-111-1131. Add their emergency contact, Steve Kerr, whose phone number is 281-111-1111 and relation i... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_with_emergency_contact_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Dennis\" AND middle_name=\"Keith\" AND last_name=\"Rodman\" AND gender=\"Non-Conforming\" AND date_of_birth=\"1961-05-13\" AND date_of_joining=\"2020-12-22\" AND department=\"Subway - SN\" AND cell_number=\"222-121-1512\" AND person_to_be_c... | Create an employee record for the employee named Dennis Keith Rodman. Their gender is Non-Conforming, date of birth is 1961-05-13, date of joining is 2020-12-22, department is Subway, and they can be reached at 222-121-1512. Add their emergency contact, Larry Bird, whose phone number is 281-232-2456 and relation is Spo... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_employee_with_emergency_contact_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE first_name=\"Scottie\" AND middle_name=\"Maurice\" AND last_name=\"Pippin\" AND gender=\"Prefer not to say\" AND date_of_birth=\"1965-09-25\" AND date_of_joining=\"2025-08-18\" AND department=\"Panera - SN\" AND cell_number=\"888-000-0000\" AND person_t... | Create an employee record for the employee named Scottie Maurice Pippin. Their gender is Prefer not to say, date of birth is 1965-09-25, date of joining is 2025-08-18, department is Panera, and they can be reached at 888-000-0000. Add their emergency contact, Magic Johnson, whose phone number is 000-000-0111 and relati... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.update_employee_department | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE employee_name=\"Ackie Monitor\" AND department=\"Dispatch\"", "count": 1} | update the profile of the employee named Ackie Monitor so their department is Dispatch | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.update_employee_department | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabEmployee` WHERE employee_name=\"Jake\" AND department=\"Management\"", "count": 1} | update the profile of the employee named Jake so their department is Management | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_journal_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"ST 6.25% - SN\" AND voucher_type=\"Debit Note\" AND company=\"ServiceNow\" AND total_debit=\"400.0\" AND total_credit=\"400.0\"", "count": 1} | create journal entry with Debit Note for entry type, ServiceNow for company, ST 6.25% - SN for account, and 400.0 for debit | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_journal_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"ST 6% - SN\" AND voucher_type=\"Opening Entry\" AND company=\"ServiceNow\" AND total_debit=\"50.0\" AND total_credit=\"50.0\"", "count": 1} | create journal entry with Opening Entry for entry type, ServiceNow for company, ST 6% - SN for account, and 50.0 for debit | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_journal_entry_with_account_dependency_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` AS je INNER JOIN `tabAccount` AS a ON je.title=a.name WHERE je.voucher_type=\"Debit Note\" AND je.company=\"ServiceNow\" AND a.account_name=\"Hello There\" AND a.account_number=\"1234567\" AND a.parent_account=\"Accounts Receivable - SN\" AND je.total_de... | Create a Debit Note-type journal entry with ServiceNow as the company, 1234567 - Hello There - SN as the account, and $400350.0 as the debit amount. If the 1234567 - Hello There - SN account does not exist, create it with 'Hello There' as the account name, '1234567' as the account number and Accounts Receivable - SN as... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_journal_entry_with_account_dependency_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` AS je INNER JOIN `tabAccount` AS a ON je.title=a.name WHERE je.voucher_type=\"Credit Card Entry\" AND je.company=\"ServiceNow\" AND a.account_name=\"Good Morning\" AND a.account_number=\"1234566\" AND a.parent_account=\"Cash In Hand - SN\" AND je.total_d... | Create a Credit Card Entry-type journal entry with ServiceNow as the company, 1234566 - Good Morning - SN as the account, and $5008.0 as the debit amount. If the 1234566 - Good Morning - SN account does not exist, create it with 'Good Morning' as the account name, '1234566' as the account number and Cash In Hand - SN a... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_cost_center_cheque_date_reference | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE payment_type=\"Pay\" AND company=\"ServiceNow\" AND mode_of_payment=\"Check\" AND party_name=\"ACME Corp.\" AND paid_to=\"Creditors - SN\" AND paid_amount=\"10000.0\" AND reference_no=\"123456\" AND reference_date=\"2025-09-17\" AND cost_center=\"M... | create a new payment entry with Pay for payment type, ServiceNow for company, ACME Corp. for party, Creditors - SN for account paid to, 10000.0 for paid amount, Check for mode of payment, 123456 for cheque number, 2025-09-17 for cheque date, and Main - SN for cost center | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_cost_center_cheque_date_reference | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE payment_type=\"Receive\" AND company=\"ServiceNow\" AND mode_of_payment=\"Wire Transfer\" AND party_name=\"Beth Anglin\" AND paid_to=\"Bank Account - SN\" AND paid_amount=\"300.0\" AND reference_no=\"789012\" AND reference_date=\"2025-10-25\" AND c... | create a new payment entry with Receive for payment type, ServiceNow for company, Beth Anglin for party, Bank Account - SN for account paid to, 300.0 for paid amount, Wire Transfer for mode of payment, 789012 for cheque number, 2025-10-25 for cheque date, and Secondary - SN for cost center | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_customer_account_project_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabCustomer` AS c ON pe.party=c.customer_name INNER JOIN `tabDynamic Link` AS dl ON dl.link_name=c.name AND dl.link_doctype=\"Customer\" INNER JOIN tabContact AS ct ON ct.name=dl.parent INNER JOIN `tabAccount` AS a ON pe.paid_to=a.name ... | Create a payment entry with: - 'Pay' for payment type - 'ServiceNow' for company - 'Cash' for mode of payment - 'Customer' for party type - 'Wowowow' for party - 'Lalalala Land - SN' for account paid to - $300.0 for paid amount - 'US ST 4%' for sales tax and charges template - 'Project A' for project If the customer Wo... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_customer_account_project_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabCustomer` AS c ON pe.party=c.customer_name INNER JOIN `tabDynamic Link` AS dl ON dl.link_name=c.name AND dl.link_doctype=\"Customer\" INNER JOIN tabContact AS ct ON ct.name=dl.parent INNER JOIN `tabAccount` AS a ON pe.paid_to=a.name ... | Create a payment entry with: - 'Pay' for payment type - 'ServiceNow' for company - 'Cash' for mode of payment - 'Customer' for party type - 'Yayayay' for party - 'Moonlight - SN' for account paid to - $5500.0 for paid amount - 'US ST 6%' for sales tax and charges template - 'Project B' for project If the customer Yayay... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_customer_account_project_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabCustomer` AS c ON pe.party=c.customer_name INNER JOIN `tabDynamic Link` AS dl ON dl.link_name=c.name AND dl.link_doctype=\"Customer\" INNER JOIN tabContact AS ct ON ct.name=dl.parent INNER JOIN `tabAccount` AS a ON pe.paid_to=a.name ... | Create a payment entry with: - 'Pay' for payment type - 'ServiceNow' for company - 'Cash' for mode of payment - 'Customer' for party type - 'Huhuhuh' for party - 'Sunlight - SN' for account paid to - $12399.0 for paid amount - 'US ST 6.25%' for sales tax and charges template - 'Project C' for project If the customer Hu... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_mode_of_payment_account_supplier_cost_center_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabMode of Payment` AS mop ON pe.mode_of_payment=mop.name INNER JOIN `tabMode of Payment Account` AS mopa ON mop.name=mopa.parent INNER JOIN `tabAccount` AS a ON mopa.default_account=a.name INNER JOIN `tabSupplier` AS s ON pe.party=s.na... | Create a payment entry with payment type 'Pay', mode of payment 'Pigeon', party 'SPECTRE', paid amount $10000.0, and cost center '12345 - Bucky's - SN'. If there is no mode of payment named Pigeon, create it with type set to 'Cash', company set to 'ServiceNow', and default account set to 'Certificate of Deposits - SN'.... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_mode_of_payment_account_supplier_cost_center_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabMode of Payment` AS mop ON pe.mode_of_payment=mop.name INNER JOIN `tabMode of Payment Account` AS mopa ON mop.name=mopa.parent INNER JOIN `tabAccount` AS a ON mopa.default_account=a.name INNER JOIN `tabSupplier` AS s ON pe.party=s.na... | Create a payment entry with payment type 'Pay', mode of payment 'Boat', party 'Quantum', paid amount $300.0, and cost center '31459 - Andy's - SN'. If there is no mode of payment named Boat, create it with type set to 'General', company set to 'ServiceNow', and default account set to 'Checking - SN'. If there is no acc... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_with_mode_of_payment_account_supplier_cost_center_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` AS pe INNER JOIN `tabMode of Payment` AS mop ON pe.mode_of_payment=mop.name INNER JOIN `tabMode of Payment Account` AS mopa ON mop.name=mopa.parent INNER JOIN `tabAccount` AS a ON mopa.default_account=a.name INNER JOIN `tabSupplier` AS s ON pe.party=s.na... | Create a payment entry with payment type 'Pay', mode of payment 'Telepathy', party 'Fillet of Soul', paid amount $500.0, and cost center '727881 - Ralph's - SN'. If there is no mode of payment named Telepathy, create it with type set to 'Phone', company set to 'ServiceNow', and default account set to 'Savings - SN'. If... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_without_cost_center | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE payment_type=\"Pay\" AND company=\"ServiceNow\" AND mode_of_payment=\"Cash\" AND party_name=\"We Sell Chips\" AND paid_to=\"Employee Advances - SN\" AND paid_amount=\"100.0\"", "count": 1} | create payment entry with Pay for payment type, ServiceNow for company, Cash for mode of payment, We Sell Chips for party, Employee Advances - SN for account paid to, and 100.0 for paid amount | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_payment_entry_without_cost_center | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE payment_type=\"Receive\" AND company=\"ServiceNow\" AND mode_of_payment=\"Cash\" AND party_name=\"Horchata Ltd.\" AND paid_to=\"Cash - SN\" AND paid_amount=\"300.0\"", "count": 1} | create payment entry with Receive for payment type, ServiceNow for company, Cash for mode of payment, Horchata Ltd. for party, Cash - SN for account paid to, and 300.0 for paid amount | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.assign_journal_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"Cash - SN\" AND _assign LIKE CONCAT(\"%\", (SELECT email FROM `tabUser` WHERE full_name=\"Queen\"), \"%\")", "count": 1} | assign journal entry titled Cash - SN to the user Queen | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.assign_journal_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"Earnest Money - SN\" AND _assign LIKE CONCAT(\"%\", (SELECT email FROM `tabUser` WHERE full_name=\"Beyonce\"), \"%\")", "count": 1} | assign journal entry titled Earnest Money - SN to the user Beyonce | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_journal_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"The Boys\" AND docstatus=2", "count": 1} | cancel journal entry named The Boys | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_journal_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"Scooter\" AND docstatus=2", "count": 1} | cancel journal entry named Scooter | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_journal_entry | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabJournal Entry` WHERE title=\"Genie\" AND docstatus=2", "count": 1} | cancel journal entry named Genie | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.assign_payment_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE title=\"MA Inc.\" AND _assign LIKE CONCAT(\"%\", (SELECT email FROM `tabUser` WHERE full_name=\"Lizzie\"), \"%\")", "count": 1} | assign payment entry named MA Inc. to the user named Lizzie | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.assign_payment_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE title=\"Orlando\" AND _assign LIKE CONCAT(\"%\", (SELECT email FROM `tabUser` WHERE full_name=\"Eugene Krabs\"), \"%\")", "count": 1} | assign payment entry named Orlando to the user named Eugene Krabs | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_payment_entry | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE title=\"Ltd.\" AND status=\"Cancelled\"", "count": 1} | cancel payment entry named Ltd. | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_payment_entry | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE title=\"Father\" AND status=\"Cancelled\"", "count": 1} | cancel payment entry named Father | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.cancel_payment_entry | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabPayment Entry` WHERE title=\"Okoye\" AND status=\"Cancelled\"", "count": 1} | cancel payment entry named Okoye | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_customer_full_address_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabCustomer` AS c ON p.customer=c.name INNER JOIN `tabAddress` AS a ON c.customer_primary_address=a.name WHERE p.project_name=\"Starlord\" AND p.priority=\"Low\" AND p.notes LIKE \"%take out the trash%\" AND p.company=\"ServiceNow\" AND p.cust... | Create a Low priority project named Starlord. Bill it to the company ServiceNow and add a note that says 'take out the trash'. Add Rachel Weisz as the project customer but if they're not in the system, create their record, entering Rachel Weisz for their name, Company for customer type, USD for billing currency, www.ra... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_customer_full_address_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabCustomer` AS c ON p.customer=c.name INNER JOIN `tabAddress` AS a ON c.customer_primary_address=a.name WHERE p.project_name=\"Gamora\" AND p.priority=\"Medium\" AND p.notes LIKE \"%return Blockbuster movie%\" AND p.company=\"ServiceNow\" AND... | Create a Medium priority project named Gamora. Bill it to the company ServiceNow and add a note that says 'return Blockbuster movie'. Add Kirsty Swanson as the project customer but if they're not in the system, create their record, entering Kirsty Swanson for their name, Individual for customer type, USD for billing cu... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_customer_full_address_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabCustomer` AS c ON p.customer=c.name INNER JOIN `tabAddress` AS a ON c.customer_primary_address=a.name WHERE p.project_name=\"Rocket\" AND p.priority=\"High\" AND p.notes LIKE \"%this is a note%\" AND p.company=\"ServiceNow\" AND p.customer=... | Create a High priority project named Rocket. Bill it to the company ServiceNow and add a note that says 'this is a note'. Add Jane Goodall as the project customer but if they're not in the system, create their record, entering Jane Goodall for their name, Individual for customer type, USD for billing currency, www.jane... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Pasta\" AND company=\"ServiceNow\"", "count": 1} | create a new project with Pasta for project name and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"SmashBurger\" AND company=\"ServiceNow\"", "count": 1} | create a new project with SmashBurger for project name and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Fresas con Crema\" AND company=\"ServiceNow\"", "count": 1} | create a new project with Fresas con Crema for project name and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Starlord\" AND company=\"ServiceNow\" AND priority=\"Low\" AND notes LIKE \"%take out the trash%\"", "count": 1} | create a new project with Starlord for project name, Low for priority, "take out the trash" for note, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Gamora\" AND company=\"ServiceNow\" AND priority=\"Medium\" AND notes LIKE \"%return Blockbuster movie%\"", "count": 1} | create a new project with Gamora for project name, Medium for priority, "return Blockbuster movie" for note, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Rocket\" AND company=\"ServiceNow\" AND priority=\"High\" AND notes LIKE \"%this is a note%\"", "count": 1} | create a new project with Rocket for project name, High for priority, "this is a note" for note, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note_dept_cost | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"JJK\" AND company=\"ServiceNow\" AND priority=\"Low\" AND notes LIKE \"%hello clarice%\" AND department=\"Operations\" AND estimated_costing=\"300\"", "count": 1} | create a new project with JJK for project name, Low for priority, "hello clarice" for note, Operations for department, 300 for estimated cost, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note_dept_cost | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"AOT\" AND company=\"ServiceNow\" AND priority=\"Medium\" AND notes LIKE \"%do you want to play a game%\" AND department=\"Management\" AND estimated_costing=\"400\"", "count": 1} | create a new project with AOT for project name, Medium for priority, "do you want to play a game" for note, Management for department, 400 for estimated cost, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_name_company_priority_note_dept_cost | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"KNY\" AND company=\"ServiceNow\" AND priority=\"High\" AND notes LIKE \"%favorite scary movie%\" AND department=\"Dispatch\" AND estimated_costing=\"100\"", "count": 1} | create a new project with KNY for project name, High for priority, "favorite scary movie" for note, Dispatch for department, 100 for estimated cost, and ServiceNow for company | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_cost_center_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name WHERE p.project_name=\"Tuna Melt\" AND p.status=\"Open\" AND p.priority=\"Low\" AND p.percent_complete_method=\"Task Progress\" AND p.departm... | Create a new project with Tuna Melt for project name, Open for status, Minerals for project type, Low for priority, L Train - SN for department, and Task Progress for % complete method. Under Notes, add a note 'let's sit down' and under Costing and Billing, fill in '123' for estimated cost, 'ServiceNow' for company, an... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_cost_center_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name WHERE p.project_name=\"S&P Regular\" AND p.status=\"Open\" AND p.priority=\"Medium\" AND p.percent_complete_method=\"Manual\" AND p.departmen... | Create a new project with S&P Regular for project name, Open for status, Rocks for project type, Medium for priority, J Train - SN for department, and Manual for % complete method. Under Notes, add a note 'where's our waiter' and under Costing and Billing, fill in '3400' for estimated cost, 'ServiceNow' for company, an... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_cost_center_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name WHERE p.project_name=\"BLT\" AND p.status=\"Open\" AND p.priority=\"High\" AND p.percent_complete_method=\"Task Completion\" AND p.department... | Create a new project with BLT for project name, Open for status, Gems for project type, High for priority, S Train - SN for department, and Task Completion for % complete method. Under Notes, add a note 'I'm so hungry' and under Costing and Billing, fill in '500500' for estimated cost, 'ServiceNow' for company, and 'Ja... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_customer_cost_center_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name INNER JOIN `tabCustomer` AS c ON p.customer=c.name WHERE p.project_name=\"Double Down\" AND p.status=\"Open\" AND p.priority=\"Low\" AND p.pe... | Create a new project with Double Down for project name, Open for status, Hard one for project type, Task Progress for % percent complete method, Low for priority, and Washing - SN for department. Add the customer West World to the project, the note 'I think I miss my wife', and an estimated cost of 12000. Set the compa... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_customer_cost_center_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name INNER JOIN `tabCustomer` AS c ON p.customer=c.name WHERE p.project_name=\"Double Up\" AND p.status=\"Open\" AND p.priority=\"Medium\" AND p.p... | Create a new project with Double Up for project name, Open for status, Easy one for project type, Manual for % percent complete method, Medium for priority, and Drying - SN for department. Add the customer East World to the project, the note 'Think mark think', and an estimated cost of 5000. Set the company to ServiceN... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_customer_cost_center_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name INNER JOIN `tabCost Center` AS cc ON p.cost_center=cc.name INNER JOIN `tabCustomer` AS c ON p.customer=c.name WHERE p.project_name=\"Double or Nothing\" AND p.status=\"Open\" AND p.priority=\"High\" A... | Create a new project with Double or Nothing for project name, Open for status, Medium one for project type, Task Completion for % percent complete method, High for priority, and Folding - SN for department. Add the customer South World to the project, the note 'Invincible is a good show', and an estimated cost of 10000... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name WHERE p.project_name=\"Language Arts\" AND p.status=\"Open\" AND p.priority=\"Low\" AND p.percent_complete_method=\"Task Progress\" AND p.department=\"The Midnight Gospel - SN\" AND d.payroll_cost_cen... | Create a new project named Language Arts with Open status and Low priority. Set the project type to Beer and associate it with the The Midnight Gospel - SN department. Set the % complete method as Task Progress and add the note 'trivia tonight'. Finally, under Costing and Billing, set the estimated cost as 100, company... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name WHERE p.project_name=\"Science\" AND p.status=\"Open\" AND p.priority=\"Medium\" AND p.percent_complete_method=\"Task Weight\" AND p.department=\"Invincible - SN\" AND d.payroll_cost_center=\"Main - S... | Create a new project named Science with Open status and Medium priority. Set the project type to Wine and associate it with the Invincible - SN department. Set the % complete method as Task Weight and add the note 'so excited'. Finally, under Costing and Billing, set the estimated cost as 3000, company as ServiceNow, a... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_project_with_type_dept_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabProject` AS p INNER JOIN `tabDepartment` AS d ON p.department=d.name WHERE p.project_name=\"Math\" AND p.status=\"Open\" AND p.priority=\"High\" AND p.percent_complete_method=\"Manual\" AND p.department=\"Smiling Friends - SN\" AND d.payroll_cost_center=\"Secondary - S... | Create a new project named Math with Open status and High priority. Set the project type to Shot and associate it with the Smiling Friends - SN department. Set the % complete method as Manual and add the note 'yay so excited!'. Finally, under Costing and Billing, set the estimated cost as 500, company as ServiceNow, an... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_dept_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` as p ON t.project=p.name WHERE t.subject=\"Chicken Meal\" AND t.status=\"Open\" AND t.priority=\"Low\" AND p.project_name=\"Listen\" AND t.type=\"Pasta\" AND t.exp_start_date=\"2025-11-14\" AND t.exp_end_date=\"2026-05-18\" AND t.expe... | Create a task with the subject 'Chicken Meal' for the project 'Listen' with Open status and Low priority. The task type should be Pasta and department should be State Department - SN. Regarding timeline, set the expected start date as 2025-11-14, the expected end date as 2026-05-18, the expected time as 5 hours, and th... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_dept_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` as p ON t.project=p.name WHERE t.subject=\"Dollar Menu\" AND t.status=\"Working\" AND t.priority=\"Medium\" AND p.project_name=\"Hear\" AND t.type=\"Salt\" AND t.exp_start_date=\"2025-12-23\" AND t.exp_end_date=\"2025-12-20\" AND t.ex... | Create a task with the subject 'Dollar Menu' for the project 'Hear' with Working status and Medium priority. The task type should be Salt and department should be Defense Department - SN. Regarding timeline, set the expected start date as 2025-12-23, the expected end date as 2025-12-20, the expected time as 10 hours, a... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_dept_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` as p ON t.project=p.name WHERE t.subject=\"Large Drink\" AND t.status=\"Pending Review\" AND t.priority=\"High\" AND p.project_name=\"See\" AND t.type=\"Pepper\" AND t.exp_start_date=\"2025-12-18\" AND t.exp_end_date=\"2025-12-28\" AN... | Create a task with the subject 'Large Drink' for the project 'See' with Pending Review status and High priority. The task type should be Pepper and department should be Treasury Department - SN. Regarding timeline, set the expected start date as 2025-12-18, the expected end date as 2025-12-28, the expected time as 20 h... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_parent_dept_dependencies_HARD | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Tell Mojito he's a good boy\" AND t.status=\"Open\" AND p.project_name=\"Jordan's Pet Care Guide\" AND t.priority=\"Low\" AND t.type=\"Standard\" AND t.parent_task=(SELECT name FROM `tabTask`... | Create a new task called 'Tell Mojito he's a good boy' for the project Jordan's Pet Care Guide. Its status should be Open and priority should be Low. Set its task type to Standard, parent task to Care for a parrot, expected start date to 2025-12-14, expected end date to 2025-12-14, expected time to 0.25 hour(s), progre... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_parent_dept_dependencies_HARD | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Acclimate Boba to human touch\" AND t.status=\"Open\" AND p.project_name=\"Jordan's Pet Care Guide\" AND t.priority=\"Medium\" AND t.type=\"Milestone\" AND t.parent_task=(SELECT name FROM `ta... | Create a new task called 'Acclimate Boba to human touch' for the project Jordan's Pet Care Guide. Its status should be Open and priority should be Medium. Set its task type to Milestone, parent task to Care for a snake, expected start date to 2025-12-26, expected end date to 2026-12-26, expected time to 1 hour(s), prog... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_project_type_parent_dept_dependencies_HARD | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Clean Miso's playpen\" AND t.status=\"Open\" AND p.project_name=\"Jordan's Pet Care Guide\" AND t.priority=\"High\" AND t.type=\"Deliverable\" AND t.parent_task=(SELECT name FROM `tabTask` WH... | Create a new task called 'Clean Miso's playpen' for the project Jordan's Pet Care Guide. Its status should be Open and priority should be High. Set its task type to Deliverable, parent task to Care for a rabbit, expected start date to 2025-12-19, expected end date to 2025-12-20, expected time to 1.5 hour(s), progress p... | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabTask AS t INNER JOIN tabProject AS p ON t.project=p.name WHERE t.subject=\"start new project\" AND p.project_name=\"Viper\"", "count": 1} | create a new task with start new project for subject and Viper for project | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabTask AS t INNER JOIN tabProject AS p ON t.project=p.name WHERE t.subject=\"discuss new deadline\" AND p.project_name=\"Boa\"", "count": 1} | create a new task with discuss new deadline for subject and Boa for project | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"lets go\" AND t.priority=\"Low\" AND p.project_name=\"Cricket\" AND t.department=\"Dispatch\"", "count": 1} | create a new task with lets go for subject, Cricket for project, Low for priority, and Dispatch for department | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"to the movies\" AND t.priority=\"Medium\" AND p.project_name=\"Fly\" AND t.department=\"Marketing\"", "count": 1} | create a new task with to the movies for subject, Fly for project, Medium for priority, and Marketing for department | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"tomorrow\" AND t.priority=\"High\" AND p.project_name=\"Beetle\" AND t.department=\"Operations\"", "count": 1} | create a new task with tomorrow for subject, Beetle for project, High for priority, and Operations for department | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept_comment | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Best of Five\" AND p.project_name=\"Faker\" AND t.priority=\"Low\" AND t.department=\"Dispatch\" AND t._comments LIKE \"%tremendous achievement%\"", "count": 1} | create a new task with Best of Five for subject, Faker for project, Low for priority, and Dispatch for department. leave a comment "tremendous achievement" after creating the task | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept_comment | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Best of Seven\" AND p.project_name=\"Keria\" AND t.priority=\"Medium\" AND t.department=\"Marketing\" AND t._comments LIKE \"%great team%\"", "count": 1} | create a new task with Best of Seven for subject, Keria for project, Medium for priority, and Marketing for department. leave a comment "great team" after creating the task | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.create_task_with_subject_project_priority_dept_comment | 2 | {"sql": "SELECT COUNT(*) AS results_count FROM `tabTask` AS t INNER JOIN `tabProject` AS p ON t.project=p.name WHERE t.subject=\"Winner Winner\" AND p.project_name=\"Beryl\" AND t.priority=\"High\" AND t.department=\"Operations\" AND t._comments LIKE \"%truth and justice%\"", "count": 1} | create a new task with Winner Winner for subject, Beryl for project, High for priority, and Operations for department. leave a comment "truth and justice" after creating the task | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.change_project_status | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Asian Water Monitor\" AND status=\"Completed\"", "count": 1} | update project named Asian Water Monitor to Completed status | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.change_project_status | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Templeton\" AND status=\"Cancelled\"", "count": 1} | update project named Templeton to Cancelled status | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.delete_project | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Valorant\"", "count": 0} | delete project Valorant | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.delete_project | 1 | {"sql": "SELECT COUNT(*) AS results_count FROM tabProject WHERE project_name=\"Temporary project\"", "count": 0} | delete project Temporary project | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... | |
erpnext | erpnext.assign_task | 0 | {"sql": "SELECT COUNT(*) AS results_count FROM tabTask WHERE subject=\"set deadline\" AND _assign LIKE CONCAT(\"%\", (SELECT email FROM tabUser WHERE full_name=\"Mingi\"), \"%\")", "count": 1} | Assign set deadline task to the user Mingi | import json
import os
from typing import Any, Dict, List
import requests
def validate(messages: List[Dict[str, str]], config: Dict[str, Any]) -> int:
if not messages:
raise ValueError("Target must contain 'messages'")
# Check whether we have the necessary information to validate
if not "sql" in... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.