Multi-line prompts are difficult to retrieve from the result table
philpax opened this issue · 0 comments
philpax commented
While working on the problem described in #15, I completed one run and had a table produced of the results.
Unfortunately, the resulting prompts are multi-line and quite long, which makes the table rather unwieldy:
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------+
| Prompt | Rating |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------+
| You have to analyze a given string to identify any dates it may contain and categorize the dates according to their granularity - millennium, century, decade, year, month, or day. Once you identify these dates, you need to convert them into a structured JSON array. Each element of the array should follow the given TypeScript schema, and should contain the identified date and optionally any relevant metadata from the string. | 1297.3925847169814 |
| | |
| Your task is to process the string in a way that considers all types of date representations. Certain dates may be ranges, for instance "1920-1973", which need to be separated into "start" and "end" and categorized respectively. For dates specified in multiple calendar systems, you should prioritize and return the date in the Gregorian (New Style) calendar. If a date only specifies one half of a range (e.g., "pre-1730"), you should ignore it. When the string does not contain any dates, you should return an empty array. | |
| Using the given description of the use-case, please parse and convert a string that may contain dates into a specific JSON array. Each element of the array should match the structure of the TypeScript schema provided: A string can be identified as either "Millennium", "Century", "Decade", "Year", "Month", "Day", "Range", "Ambiguous", or "Present". Each category should be followed by the corresponding year, month or day, as well as an optional metadata string. If the string contains no dates, you should return an empty array. Exclude dates that form one half of a range (for example "pre-1730"). If a date is given in multiple calendar systems, select the Gregorian/NS/New Style date and disregard the others. | 1243.026647667641 |
| Your task is to analyze strings that may contain dates of various formats, such as single days, months, years, decades, centuries, millennia, ranges, or ambiguously defined time periods, and possibly non-date elements. You should return a JSON array with elements representing each date you recognize in the string. Each element must conform to a TypeScript schema: | 1234.4011803833216 |
| | |
| - "Millennium": { "year": number, "metadata"?: string } | |
| - "Century": { "year": number, "metadata"?: string } | |
| - "Decade": { "year": number, "metadata"?: string } | |
| - "Year": { "year": number, "metadata"?: string } | |
| - "Month": { "year": number, "month": number, "metadata"?: string } | |
| - "Day": { "year": number, "month": number, "day": number, "metadata"?: string } | |
| - "Range": { "start": Result, "end": Result, "metadata"?: string } | |
| - "Ambiguous": Result[] | |
| - "Present": { "metadata"?: string } | |
| | |
| Always prioritize the Gregorian/NS/New Style interpretation when multiple date systems are used. If there are no dates in the string, return an empty array. If a date is used to indicate one end of a range but the other end is not specified (e.g., "pre-2000"), do not create a "Range" object for it. Also, remember to handle ambiguous dates by creating an "Ambiguous" object with a list of plausible interpretations. Always remember to add additional non-date information in the string, if present, as metadata to the respective dating element. | |
| Your task is to accurately interpret and convert a diverse set of date formats from a given string into structured JSON data. The JSON array you generate should consist of individual elements that follow specific schemas such as "Millennium", "Century", "Decade", "Year", "Month", "Day", "Range", "Ambiguous", and "Present". All of these schemas are associated with a particular year, and some additionally require month, day, or metadata. In the case of "Range", you'll be handling a start and end date which can be any of the other date schemas. If the input string has periods like "pre-700" only one part of which can be considered a valid date, ignore such instances and do not generate a 'Result'. | 1217.2035701506197 |
| | |
| For example, if a string has an ambiguous date, you should categorize it under the "Ambiguous" schema. If the string contains multiple representations of a date, stick to the Gregorian/New Style (N.S) version and discard the others. | |
| | |
| If the string doesn't contain any interpretable dates, return an empty array []. Treat non-date information in the input string as metadata associated with the date. Your challenge here is to use the entity representation to the best extent whilst maintaining accuracy, comprehensibility, and consistency in extracted date information. | |
| Your task is to parse various string inputs for possible dates and time periods. You have to produce a JSON array where each element is categorized into either 'Millennium', 'Century', 'Decade', 'Year', 'Month', 'Day', 'Range', or 'Ambiguous'. Each category should have 'year' as a key and may include an optional 'metadata' key. The 'Range' category contains two 'Result' type objects in 'start' and 'end' keys, and an optional 'metadata'. 'Ambiguous' contains an array of 'Result' type objects. If the input has no date-like information, produce an empty array. If a date forms only part of a range, like 'pre-2020', neglect it. If a date is expressed in different calendars, use the Gregorian or New Style (NS) system and ignore the other systems. | 1214.5539587548917 |
| Your task involves interpreting various forms of date references from a given string and transcribing these into a specific JSON array format. The array components can be of distinct types: "Millennium", "Century", "Decade", "Year", "Month", "Day", "Range", "Ambiguous", and "Present", each with an associated 'year' attribute and an optional 'metadata'. For "Month" and "Day" types, additional 'month' and 'day' attributes are required. If the string contains a time span, represent it as a "Range" type, with 'start' and 'end' components, each having their own respective date type. If the date is unclear, encode it as "Ambiguous" with all possible interpretations. However, if a date is only part of a range (like "pre-1730"), do not convert it into the 'Result' format. For dates presented in multiple systems, focus on the Gregorian/New Style dates, disregarding the others. If there are no dates in the string, your output should be an empty array. | 1201.7252458028424 |
| Your task is to interpret a provided string which may contain dates. You have to generate a JSON array, where each element represents a date entity indicated in the string and fits into one of the defined TypeScript schema categories: Millennium, Century, Decade, Year, Month, Day, Range, Ambiguous or Present. | 1167.763957429434 |
| | |
| You have to provide year, month, or day depending on the category. Some dates might be associated with some non-date information (metadata), capture that too. However, if the input string contains no dates, you should return an empty array. | |
| | |
| In case of a date range, a 'start' and 'end' date should be provided, but ignore ranges that have only one end specified (i.e., "pre-1730"). If a date is presented in multiple calendar systems, rely on the Gregorian/New Style system while ignoring the others. | |
| Your task is to convert a given string into a JSON array consisting of elements that represent different timelines such as Millennium, Century, Decade, Year, Month, Day, and Range. The string can contain dates, time periods, or simply names of places or events, which you need to interpret correctly. | 1163.6446257993205 |
| | |
| For instance, if it's a specific year, you must identify it as a 'Year' with the corresponding 'year' detail. If a range of years is given, you should categorize it as 'Range' and provide 'start' and 'end' details respectively. Same goes for Millennium, Century, Decade, Month, and Day based on the information available in the string. | |
| | |
| If the string has no dates, you are expected to return an empty array. Ignore any incomplete date range information like 'pre-1730'. In case the date is mentioned in different systems - like Old Style (O.S), New Style (N.S), or Gregorian - you should always prefer the Gregorian/NS/New Style date. | |
| | |
| Remember to include any other relevant metadata in the 'metadata' field if it's available in the string (like names of places). All your outputs should conform to the schema provided in the task: 'type Result' which is a combination of various timeline types. | |
| | |
| Note: The task does not require you to calculate or infer dates, just categorize and arrange the dates provided in the string into the appropriate format. | |
| As an AI, your task is to analyze a provided string which may contain dates and convert it into a structured JSON array. The dates could be in various forms, such as a specific day, month, year, decade, century, millennium, or a range of these. Each detected date should be converted into a JSON object fitting into one of the types defined in the TypeScript schema: "Millennium", "Century", "Decade", "Year", "Month", "Day", "Range", "Ambiguous", or "Present". Each type has a "year" key for the year of the date and may have a "metadata" key for extra information included in the string. "Month" and "Day" types also have "month" and "day" keys respectively, and the "Range" type has "start" and "end" keys each holding a JSON object of a date type. If a date is given in multiple date systems, only consider the Gregorian/New Style date, and ignore the others. If the string contains a date that is one half of a range such as 'pre-1730', it should not be included in the final output. In the end, if no date is detected in the string, return an empty array. | 1160.2919660816647 |
| Analyze the provided string and identify any potential date or time period information it may contain. For the found dates, classify them based on their granularity, such as "Millennium", "Century", "Decade", "Year", "Month", "Day", or a "Range" between two dates. Depending on the level of details, you should create a JSON object with the corresponding structure from the mentioned options. If the date could fall under multiple categories, create an "Ambiguous" entry with all possible interpretations. If the input string contains no identifiable date, output an empty array. For any string data associated with a date, include it as the "metadata" attribute of the corresponding JSON object. If a date is part of a range, but the other end of the range is missing (like "pre-1730"), do not generate an entry for it. When dates are provided in multiple calendar systems, prioritize the Gregorian/NS/New Style date and disregard others. | 1099.996263213283 |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------+
(apologies for pasting the whole thing in, but I wanted to demonstrate how unwieldy it was)
Instead of using a table for the prompts, I'd suggest printing them out separately, so that users can easily copy and paste from the result without having to manually remove the whitespace to extricate it from the table structure.
Alternatively, I'd suggest left-aligning on the table. While multi-line prompts would still be annoying (as you'd have to remove the table formatting yourself), at least you'd only have to remove whitespace from one side.