कार्य

नमस्कार, हेब्र! मैं ऐलिस के लिए कौशल में रुचि रखने लगा और सोचने लगा कि वे क्या लाभ ला सकते हैं। साइट पर कई अलग-अलग शांत गेम हैं (मेरा सहित), लेकिन मैं एक काम करने वाला उपकरण बनाना चाहता था जो वास्तव में आवाज के प्रदर्शन में जरूरी हो, और न केवल मौजूदा चैट बॉट को कॉपी करें बटन के साथ।

आवाज तब प्रासंगिक होती है जब या तो हाथ व्यस्त होते हैं, या आपको कई अनुक्रमिक संचालन करने की आवश्यकता होती है, खासकर फोन स्क्रीन पर। तो एक कौशल का विचार आया, जो एक आदेश द्वारा, पाठ से दिनांक और समय का एक संकेत निकालता है और इस पाठ के साथ एक घटना को Google कैलेंडर में जोड़ता है। उदाहरण के लिए, यदि कोई उपयोगकर्ता कहता है कि कल के बाद दोपहर 11 बजे एक सुंदर सूर्यास्त होगा , तो लाइन 23:00 पर कल के बाद के दिन के लिए कैलेंडर में एक सुंदर सूर्यास्त होगी ।

कटर के तहत हॉर्स लाइब्रेरी के एल्गोरिथ्म का वर्णन है: प्राकृतिक रूसी भाषण में एक तिथि और समय पहचानकर्ता। अश्व सूर्य का स्लाव देवता है।

जीठब | NuGet

मौजूदा समाधान

पाइथन में खजूर
रूसी भाषा के लिए समर्थन की घोषणा की गई है, लेकिन रूसी में पुस्तकालय बुनियादी चीजों से सामना नहीं कर सकता है:

>>> import dateparser >>> dateparser.parse(u'13  2015 .  13:34') datetime.datetime(2015, 1, 13, 13, 34) >>> dateparser.parse(u' ') >>> dateparser.parse(u'    9 ') >>> dateparser.parse(u'13 ') datetime.datetime(2019, 10, 13, 0, 0) >>> dateparser.parse(u'13   9 ')

रूबी पर जीर्ण
एक पुस्तकालय जो माणिकवादियों के लिए जाना जाता है, जिसे वे कहते हैं, अपना काम पूरी तरह से करता है। लेकिन रूसी के लिए समर्थन नहीं मिला है।

Google सहायक
चूंकि हम Google कैलेंडर में आवाज जोड़ने की बात कर रहे हैं, इसलिए हम पूछते हैं कि सहायक का उपयोग क्यों नहीं किया? यह संभव है, लेकिन परियोजना का विचार अनावश्यक वाक्यांशों और टैपों के बिना एक वाक्यांश में काम करना है। और इसे मज़बूती से करने के लिए। अब इसके लिए सहायक को समस्या है:

प्रीसेट

मैंने .NETStandard 2.0 (C #) पर एक लाइब्रेरी लिखी है। चूंकि पुस्तकालय मूल रूप से ऐलिस के लिए बनाया गया था, पाठ में सभी अंकों को संख्या माना जाता है, क्योंकि ऐलिस इस रूपांतरण को स्वचालित रूप से करता है। यदि आपके पास स्ट्रिंग्स में अंक हैं, तो संख्याओं में शब्दों को कैसे बदलना है, इस पर एक अद्भुत डूमर 3 डी लेख है ।

आकृति विज्ञान

वॉइस इनपुट के साथ काम करते समय, सही शब्दों को गलत से अलग करने का सबसे विश्वसनीय तरीका शब्द रूपों का उपयोग करना है। यैंडेक्स के एलिस स्कूल के लिए एक वीडियो ट्यूटोरियल में एक दोस्त और मैंने इस बारे में अधिक विस्तार से बात की। इस लेख में, मैं शब्द रूपों के साथ काम करने वाले दृश्यों को पीछे छोड़ दूंगा। इस तरह के निर्माण कोड में दिखाई देंगे:

 Morph.HasOneOfLemmas(t, "", "", "");

यह फ़ंक्शन true यदि शब्द t तीन निम्न शब्दों में से किसी एक का कोई रूप है, उदाहरण के लिए: अतीत , अतीत , पिछला ।

सिद्धांत

पाठ में दिनांक कैसे पकड़ें, यह समझने के लिए, आपको उन विशिष्ट वाक्यांशों को सूचीबद्ध करने की आवश्यकता है जिनका उपयोग हम वास्तविक वार्तालापों में तिथियों को इंगित करने के लिए करते हैं। उदाहरण के लिए:

- मैं कल टहलने जाऊंगा
- मैं कल रात टहलने जाऊंगा
- अगले गुरुवार मैं फिल्मों में जा रहा हूं
- अगले गुरुवार को रात 9 बजे मैं सिनेमा देखने जाता हूं
- 21 मार्च को सुबह 10 बजे बैठक

हम देखते हैं कि एक पूरे के रूप में शब्द तीन प्रकारों में विभाजित हैं:

वे जो हमेशा दिनांक और समय (महीनों और दिनों के नाम) का संदर्भ देते हैं
वे जो दूसरे शब्दों ("दिन", "शाम", "अगला", संख्याओं के सापेक्ष एक निश्चित स्थिति पर तारीख और समय से संबंधित हैं)
वो जो कभी तारीख और समय नहीं

पहले और आखिरी के साथ, सब कुछ स्पष्ट है, लेकिन दूसरे के साथ कठिनाइयां हैं। एल्गोरिथ्म का मूल संस्करण एक बड़ी संख्या के साथ एक भयानक स्पेगेटी कोड था if , क्योंकि मैंने उन सभी संभावित संयोजनों और शब्दों को ध्यान में रखने की कोशिश की जिन्हें मुझे ज़रूरत थी, लेकिन फिर मैं एक बेहतर विकल्प के साथ आया। तथ्य यह है कि मानवता ने पहले से ही एक प्रणाली का आविष्कार किया है जो आपको जल्दी और आसानी से पात्रों के क्रमपरिवर्तन और संयोजनों को ध्यान में रखने की अनुमति देता है: नियमित अभिव्यक्ति इंजन।

खाना बनाना एक लाइन

हम लाइन को टोकन में तोड़ते हैं, विराम चिह्न हटाते हैं और निचले मामले में सब कुछ कम करते हैं। उसके बाद, हम प्रत्येक गैर-खाली टोकन को एक एकल वर्ण के साथ प्रतिस्थापित करते हैं, जिससे नियमित अभिव्यक्तियों के साथ काम करना आसान हो सके।

टोकन (शब्द)	बदलने का प्रतीक
"वर्ष"	Y
महीने का नाम	एम
सप्ताह का नाम	डी
"पिछड़ा"	ख
"बाद में"	एल (कम एल)
"के माध्यम से"	मैं
"दिन बंद"	डब्ल्यू
"मिनट"	ई
"घंटे"	ज
"दिवस"	घ
"सप्ताह"	w
"महीना"	मीटर
"अतीत", "अतीत", "पिछला"	रों
"यह", "वर्तमान", "वर्तमान"	यू
"निकटतम", "भविष्य"	y
"अगला", "भविष्य"	एक्स
"परसों"	6
"कल"	5
"आज"	4
"कल"	3
"कल से पहले का दिन"	2
"मॉर्निंग"	आर
"दोपहर"	n
"शाम"	v
"रात"	जी
"आधा"	एच
"क्वार्टर"	क्यू
सी, सी	च
"से", "द्वारा"	टी
"चालू"	के बारे में
"संख्या"	#
"और"	एन
संख्या 1900 से अधिक और 9999 से कम है	1
गैर-नकारात्मक संख्या 1901 से कम है	0
दिनांक पहले से ही एल्गोरिथ्म द्वारा संसाधित	@
कोई अन्य टोकन	_

ParserExtractors.cs

internal static class ParserExtractors
{
internal static string CreatePatternFromToken(string token)
{
var t = token.ToLower().Replace("[^0-9--]", "").Trim();
if (Morph.HasOneOfLemmas(t, Keywords.Year)) return "Y";
if (Morph.HasOneOfLemmas(t, Keywords.Months().ToArray())) return "M";
if (Morph.HasOneOfLemmas(t, Keywords.DaysOfWeek().ToArray())) return "D";
if (Morph.HasOneOfLemmas(t, Keywords.PreviousPostfix)) return "b";
if (Morph.HasOneOfLemmas(t, Keywords.AfterPostfix)) return "l";
if (Morph.HasOneOfLemmas(t, Keywords.After)) return "i";
if (Morph.HasOneOfLemmas(t, Keywords.Holiday)) return "W";
var p = PeriodFromToken(t);
switch (p)
{
case Period.Minute:
return "e";
case Period.Hour:
return "h";
case Period.Day:
return "d";
case Period.Week:
return "w";
case Period.Month:
return "m";
}
var r = RelativeModeFromToken(t);
switch (r)
{
case RelativeMode.Previous:
return "s";
case RelativeMode.Current:
return "u";
case RelativeMode.CurrentNext:
return "y";
case RelativeMode.Next:
return "x";
}
var n = NeighbourDaysFromToken(t);
if (n > int.MinValue)
{
return (n + 4).ToString();
}
var d = DaytimeFromToken(t);
switch (d)
{
case DayTime.Morning:
return "r";
case DayTime.Noon:
return "n";
case DayTime.Day:
return "a";
case DayTime.Evening:
return "v";
case DayTime.Night:
return "g";
}
var pt = PartTimeFromToken(t);
switch (pt)
{
case PartTime.Quarter:
return "Q";
case PartTime.Half:
return "H";
}
if (int.TryParse(t, out var c))
{
if (c < 0 || c > 9999) return "_";
if (c > 1900) return "1";
return "0";
}
if (Morph.HasOneOfLemmas(t, Keywords.TimeFrom)) return "f";
if (Morph.HasOneOfLemmas(t, Keywords.TimeTo)) return "t";
if (Morph.HasOneOfLemmas(t, Keywords.TimeOn)) return "o";
if (Morph.HasOneOfLemmas(t, Keywords.DayInMonth)) return "#";
if (t == "") return "N";
return "_";
}
private static PartTime PartTimeFromToken(string t)
{
if (Morph.HasOneOfLemmas(t, Keywords.Quarter)) return PartTime.Quarter;
if (Morph.HasOneOfLemmas(t, Keywords.Half)) return PartTime.Half;
return PartTime.None;
}
private static DayTime DaytimeFromToken(string t)
{
if (Morph.HasOneOfLemmas(t, Keywords.Noon)) return DayTime.Noon;
if (Morph.HasOneOfLemmas(t, Keywords.Morning)) return DayTime.Morning;
if (Morph.HasOneOfLemmas(t, Keywords.Evening)) return DayTime.Evening;
if (Morph.HasOneOfLemmas(t, Keywords.Night)) return DayTime.Night;
if (Morph.HasOneOfLemmas(t, Keywords.DaytimeDay)) return DayTime.Day;
return DayTime.None;
}
private static Period PeriodFromToken(string t)
{
if (Morph.HasOneOfLemmas(t, Keywords.Year)) return Period.Year;
if (Morph.HasOneOfLemmas(t, Keywords.Month)) return Period.Month;
if (Morph.HasOneOfLemmas(t, Keywords.Week)) return Period.Week;
if (Morph.HasOneOfLemmas(t, Keywords.Day)) return Period.Day;
if (Morph.HasOneOfLemmas(t, Keywords.Hour)) return Period.Hour;
if (Morph.HasOneOfLemmas(t, Keywords.Minute)) return Period.Minute;
return Period.None;
}
private static int NeighbourDaysFromToken(string t)
{
if (Morph.HasOneOfLemmas(t, Keywords.Tomorrow)) return 1;
if (Morph.HasOneOfLemmas(t, Keywords.Today)) return 0;
if (Morph.HasOneOfLemmas(t, Keywords.AfterTomorrow)) return 2;
if (Morph.HasOneOfLemmas(t, Keywords.Yesterday)) return -1;
if (Morph.HasOneOfLemmas(t, Keywords.BeforeYesterday)) return -2;
return int.MinValue;
}
internal static RelativeMode RelativeModeFromToken(string t)
{
if (Morph.HasOneOfLemmas(t, Keywords.Current)) return RelativeMode.Current;
if (Morph.HasOneOfLemmas(t, Keywords.Next)) return RelativeMode.Next;
if (Morph.HasOneOfLemmas(t, Keywords.Previous)) return RelativeMode.Previous;
if (Morph.HasOneOfLemmas(t, Keywords.CurrentNext)) return RelativeMode.CurrentNext;
return RelativeMode.None;
}
}

view raw ParserExtractors.cs hosted with ❤ by GitHub

Keywords.cs

public class Keywords
{
public static readonly string[] After = {""};
public static readonly string[] AfterPostfix = {""};
public static readonly string[] PreviousPostfix = {""};
public static readonly string[] Next = {"", ""};
public static readonly string[] Previous = {"", "", ""};
public static readonly string[] Current = {"", "", ""};
public static readonly string[] CurrentNext = {"", ""};
public static readonly string[] Today = {""};
public static readonly string[] Tomorrow = {""};
public static readonly string[] AfterTomorrow = {""};
public static readonly string[] Yesterday = {""};
public static readonly string[] BeforeYesterday = {""};
public static readonly string[] Holiday = {""};
public static readonly string[] Second = {"", ""};
public static readonly string[] Minute = {"", ""};
public static readonly string[] Hour = {"", ""};
public static readonly string[] Day = {""};
public static readonly string[] Week = {""};
public static readonly string[] Month = {"", ""};
public static readonly string[] Year = {""};
public static readonly string[] Noon = {""};
public static readonly string[] Morning = {""};
public static readonly string[] Evening = {""};
public static readonly string[] Night = {""};
public static readonly string[] Half = {"", ""};
public static readonly string[] Quarter = {""};
public static readonly string[] DayInMonth = {""};
public static readonly string[] January = {"", ""};
public static readonly string[] February = {"", ""};
public static readonly string[] March = {"", ""};
public static readonly string[] April = {"", ""};
public static readonly string[] May = {"", ""};
public static readonly string[] June = {"", ""};
public static readonly string[] July = {"", ""};
public static readonly string[] August = {"", ""};
public static readonly string[] September = {"", "", ""};
public static readonly string[] October = {"", ""};
public static readonly string[] November = {"", "", ""};
public static readonly string[] December = {"", ""};
public static readonly string[] Monday = {"", ""};
public static readonly string[] Tuesday = {"", ""};
public static readonly string[] Wednesday = {"", ""};
public static readonly string[] Thursday = {"", ""};
public static readonly string[] Friday = {"", ""};
public static readonly string[] Saturday = {"", ""};
public static readonly string[] Sunday = {"", ""};
public static readonly string[] DaytimeDay = {"", ""};
public static readonly string[] TimeFrom = {"", ""};
public static readonly string[] TimeTo = {"", ""};
public static readonly string[] TimeOn = {""};
public static List<string[]> Months()
{
return new List<string[]>
{
January,
February,
March,
April,
May,
June,
July,
August,
September,
October,
November,
December
};
}
public static List<string[]> DaysOfWeek()
{
return new List<string[]>
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
};
}
public List<string> AllValues()
{
var values = new List<string>();
GetType()
.GetFields(BindingFlags.Static | BindingFlags.Public)
.ToList()
.ForEach(f =>
{
var words = (string[]) f.GetValue(null);
words.ToList().ForEach(values.Add);
});
return values;
}
}

view raw Keywords.cs hosted with ❤ by GitHub

यहां उन पंक्तियों का उल्लेख किया गया है जो हमने बताई हैं:

पंक्ति	परिणाम
मैं कल टहलने जाऊंगा	`5__`
कल शाम मैं टहलने जाऊंगा	`5v__`
अगले गुरुवार को मैं फिल्मों में जा रहा हूं	`fxD_f_`
अगले गुरुवार को रात 9 बजे मैं सिनेमा देखने जाता हूँ	`fxDf0v_f_`
21 मार्च को सुबह 10 बजे बैठक	`0Mf0r_`

मान्यता

- ओह, आतंक! - आप कहते हैं, - यह केवल बदतर हो गया! इस तरह की गिबरीश और व्यक्ति समझ नहीं सकते। हां, मुझे एक व्यक्ति द्वारा पढ़ने की सुविधा और नियमित रूप से काम करने की सुविधा के बीच कुछ समझौता करना पड़ा, नीचे देखें कि कैसे।

फिर हम कर्तव्यों की श्रृंखला नामक एक पैटर्न लागू करते हैं : इनपुट डेटा ऐरे को अलग-अलग प्रोसेसर में क्रमिक रूप से खिलाया जाता है, जो इसे बदल नहीं सकता है और इसे आगे प्रसारित कर सकता है। मैंने हैंडलर Recognizer फोन किया और एक विशिष्ट के प्रत्येक संस्करण के लिए ऐसा हैंडलर बनाया (जैसा कि यह मुझे लग रहा था) दिनांक और समय से संबंधित वाक्यांश।

Recognizer एक स्ट्रिंग में दिए गए रेगेक्स पैटर्न की खोज करता है और प्रत्येक मिलान के लिए एक प्रोसेसिंग फ़ंक्शन लॉन्च करता है जो इनपुट स्ट्रिंग को संशोधित कर सकता है और एक विशेष सरणी में पकड़े गए तिथियों को जोड़ सकता है।

Recognizer.cs

public abstract class Recognizer
{
public void ParseTokens(DatesRawData data, DateTime userDate)
{
ForAllMatches(data.GetPattern, pattern: GetRegexPattern(), action: m => ParseMatch(data, m, userDate));
}
public static void ForAllMatches(Func<string> input, string pattern, Predicate<Match> action, bool reversed = false)
{
var matches = Regex.Matches(input.Invoke(), pattern);
if (matches.Count == 0)
{
return;
}
var match = reversed ? matches[matches.Count - 1] : matches[0];
var indexesToSkip = new HashSet<int>();
while (match != null && match.Success)
{
var text = input.Invoke();
var matchIndex = reversed ? text.Length - match.Index : match.Index;
if (!action.Invoke(match))
{
indexesToSkip.Add(matchIndex);
}
match = null;
text = input.Invoke();
matches = Regex.Matches(text, pattern);
for (var i = 0; i < matches.Count; i++)
{
var index = reversed ? matches.Count - i - 1 : i;
matchIndex = reversed ? text.Length - matches[index].Index : matches[index].Index;
if (!indexesToSkip.Contains(matchIndex))
{
match = matches[index];
break;
}
}
}
}
protected abstract string GetRegexPattern();
protected abstract bool ParseMatch(DatesRawData data, Match match, DateTime userDate);
}

view raw Recognizer.cs hosted with ❤ by GitHub

इसके अलावा, हैंडलर को सही क्रम में बुलाया जाना चाहिए: अधिक "आत्मविश्वास" से कम तक। उदाहरण के लिए, बहुत शुरुआत में, आपको "सख्त" शब्दों से जुड़े हैंडलर को चलाने की आवश्यकता होती है जो वास्तव में तारीखों से संबंधित हैं: दिनों के नाम, महीने, "कल", "परसों के बाद के दिन" जैसे नाम। और अंत में, हैंडलर जो कच्चे संतुलन द्वारा यह निर्धारित करने की कोशिश करते हैं कि क्या तारीख से संबंधित कुछ और भी हो सकता है।

उदाहरण के लिए:

तारीख और महीना

 "((0N?)+)(M|#)"; // 24, 25, 26...  27 /

यहां नियमित अभिव्यक्तियों का उपयोग करने का आकर्षण प्रकट होने लगता है। काफी सरल तरीके से, हमने टोकन के एक जटिल अनुक्रम की पहचान की है: 1901 से कम गैर-नकारात्मक संख्याओं का एक गैर-संख्या संख्या, एक दूसरे का अनुसरण करते हैं, संभवतः "और" के मिलन से अलग हो जाता है, और या तो महीने का नाम या "संख्या" का अनुसरण करता है।

इसके अलावा, मैच समूह में हम तुरंत विशिष्ट तत्वों को पकड़ते हैं, यदि कोई हो, और यदि कोई नहीं है तो पकड़ नहीं सकते हैं, और इस सेट से हम अंतिम तिथि की रचना करते हैं। नीचे दिए गए कोड में, Fix , FixPeriod कार्यों से संबंधित एक FixPeriod अनुभाग होगा, हम लेख के अंत में इस पर आगे बढ़ेंगे।

DaysMonthRecognizer.cs

public class DaysMonthRecognizer : Recognizer
{
protected override string GetRegexPattern()
{
return "((0N?)+)(M|#)"; // 24, 25, 26... 27 /
}
protected override bool ParseMatch(DatesRawData data, Match match, DateTime userDate)
{
var dates = new List<AbstractPeriod>();
var monthFixed = false;
// parse month
var mStr = data.Tokens[match.Index + match.Groups[1].Length].Value;
var month = ParserUtils.FindIndex(mStr, Keywords.Months()) + 1;
if (month == 0) month = userDate.Month; // # instead M
else monthFixed = true;
// create dates
for (var i = match.Index; i < match.Index + match.Groups[1].Length; i++)
{
var t = data.Tokens[i];
int.TryParse(t.Value, out var day);
if (day <= 0) continue; // this is "AND" or other token
// current token is number, store it as a day
var period = new AbstractPeriod
{
Date = new DateTime(
userDate.Year,
month,
ParserUtils.GetDayValidForMonth(userDate.Year, month, day)
)
};
// fix from week to day, and year/month if it was
period.Fix(FixPeriod.Week, FixPeriod.Day);
if (monthFixed) period.Fix(FixPeriod.Month);
// store
dates.Add(period);
// compare with last if month not fixed
if (!monthFixed && dates.Count > 0 && dates.Last().Date < period.Date)
{
period.Date = new DateTime(
userDate.Year,
month + 1,
ParserUtils.GetDayValidForMonth(userDate.Year, month + 1, day)
);
}
}
// replace all scanned tokens
data.ReplaceTokensByDates(match.Index, match.Length, dates.ToArray());
return true;
}
}

view raw DaysMonthRecognizer.cs hosted with ❤ by GitHub

समय व्यतीत हो गया

 "(i)?((0?[Ymwdhe]N?)+)([bl])?"; // ()     2  4  10  (/)

यह ध्यान रखना महत्वपूर्ण है कि कभी-कभी सिर्फ नियमित मौसम के साथ संयोग के तथ्य पर्याप्त नहीं होते हैं, और आपको अभी भी हैंडलर में कुछ तर्क जोड़ने की आवश्यकता है। हालांकि, ऐसे मामलों के लिए दो अलग-अलग हैंडलर बनाना संभव था, लेकिन यह मुझे एक अतिरिक्त लग रहा था। नतीजतन, मैं प्रारंभिक "के माध्यम से" और अंतिम "बाद में / पिछड़े" दोनों से मेल खाता हूं, लेकिन हैंडलर कोड एक चेक से शुरू होता है:

 if (match.Groups[1].Success ^ match.Groups[4].Success)

कहां ^ अनन्य है या।

TimeSpanRecognizer.cs

public class TimeSpanRecognizer : Recognizer
{
protected override string GetRegexPattern()
{
return "(i)?((0?[Ymwdhe]N?)+)([bl])?"; // () 2 4 10 (/)
}
protected override bool ParseMatch(DatesRawData data, Match match, DateTime userDate)
{
if (match.Groups[1].Success ^ match.Groups[4].Success)
{
// if "after" of "before", but not both and not neither
var letters = match.Groups[2].Value.Select(s => s.ToString()).ToList();
var lastNumber = 1;
var tokenIndex = match.Groups[2].Index;
var direction = 1; // moving to the future
if (match.Groups[4].Success && match.Groups[4].Value == "b")
{
direction = -1; // "before"
}
var date = new AbstractPeriod
{
SpanDirection = direction,
};
// save current day to offser object
var offset = new DateTimeOffset(userDate);
letters.ForEach(l =>
{
switch (l)
{
case "N": // "and", skip it
break;
case "0": // number, store it
int.TryParse(data.Tokens[tokenIndex].Value, out lastNumber);
break;
case "Y": // year(s)
offset = offset.AddYears(direction * lastNumber);
date.FixDownTo(FixPeriod.Month);
lastNumber = 1;
break;
case "m": // month(s)
offset = offset.AddMonths(direction * lastNumber);
date.FixDownTo(FixPeriod.Week);
lastNumber = 1;
break;
case "w": // week(s)
offset = offset.AddDays(7 * direction * lastNumber);
date.FixDownTo(FixPeriod.Day);
lastNumber = 1;
break;
case "d": // day(s)
offset = offset.AddDays(direction * lastNumber);
date.FixDownTo(FixPeriod.Day);
lastNumber = 1;
break;
case "h": // hour(s)
offset = offset.AddHours(direction * lastNumber);
date.FixDownTo(FixPeriod.Time);
lastNumber = 1;
break;
case "e": // minute(s)
offset = offset.AddMinutes(direction * lastNumber);
date.FixDownTo(FixPeriod.Time);
break;
}
tokenIndex++;
});
// set date
date.Date = new DateTime(offset.DateTime.Year, offset.DateTime.Month, offset.DateTime.Day);
if (date.IsFixed(FixPeriod.Time))
date.Time = new TimeSpan(offset.DateTime.Hour, offset.DateTime.Minute, 0);
date.Span = offset - userDate;
// remove and insert
data.ReplaceTokensByDates(match.Index, match.Length, date);
return true;
}
return false;
}
}

view raw TimeSpanRecognizer.cs hosted with ❤ by GitHub

वैसे, ऐसे कार्यों के लिए काम करने के लिए, इंजन को उपयोगकर्ता की वर्तमान तिथि को स्थानांतरित करने की आवश्यकता होती है।

साल

 "(1)Y?|(0)Y"; // [] 15 /2017 ()

मैं एक बार फिर नियमित के साथ दृष्टिकोण की सुविधा को नोट नहीं कर सकता। फिर, एक सरल अभिव्यक्ति के साथ, हमने तुरंत विकल्पों का संकेत दिया: उपयोगकर्ता एक वर्ष के समान संख्या का नाम देता है, लेकिन शब्द "वर्ष" के बिना, या उपयोगकर्ता एक दो-अंकीय संख्या (जो एक तिथि हो सकती है) का नाम देता है, लेकिन "वर्ष" शब्द जोड़ता है, और भावों का समर्थन करता है "में"। 18 वर्ष, "हालांकि, हमें नहीं पता कि इसका मतलब 1918 या 2018 है, इसलिए हम मानते हैं कि 2018।

YearRecognizer.cs

public class YearRecognizer : Recognizer
{
protected override string GetRegexPattern()
{
return "(1)Y?|(0)Y"; // [] 15 /2017 ()
}
protected override bool ParseMatch(DatesRawData data, Match match, DateTime userDate)
{
// just year number
int.TryParse(data.Tokens[match.Index].Value, out var n);
var year = ParserUtils.GetYearFromNumber(n);
// insert date
var date = new AbstractPeriod
{
Date = new DateTime(year, 1, 1)
};
date.Fix(FixPeriod.Year);
// remove and insert
data.ReplaceTokensByDates(match.Index, match.Length, date);
return true;
}
}

view raw YearRecognizer.cs hosted with ❤ by GitHub

समय

 "([rvgd])?([fot])?(Q|H)?(h|(0)(h)?)((0)e?)?([rvgd])?"; // (//) (/) /9 () (30 ()) (///)

मेरे संग्रह में सबसे कठिन अभिव्यक्ति दिन के समय को इंगित करने के लिए वाक्यांशों के लिए जिम्मेदार है, सुबह 9.30 बजे से एक चौथाई से 11 बजे तक।

TimeRecognizer.cs

public class TimeRecognizer : Recognizer
{
protected override string GetRegexPattern()
{
return "([rvgd])?([fot])?(Q|H)?(h|(0)(h)?)((0)e?)?([rvgd])?"; // (//) (/) /9 () (30 ()) (///)
}
protected override bool ParseMatch(DatesRawData data, Match match, DateTime userDate)
{
// determine if it is time
if (
match.Groups[5].Success //
|| match.Groups[6].Success // ""
|| match.Groups[4].Success // ""
|| match.Groups[1].Success // "///"
|| match.Groups[9].Success //
)
{
if (!match.Groups[5].Success)
{
// no number in phrase
var partOfDay = match.Groups[9].Success
? match.Groups[9].Value
: match.Groups[1].Success
? match.Groups[1].Value
: "";
// no part of day AND no "from" token in phrase, quit
if (partOfDay != "d" && partOfDay != "g" && !match.Groups[2].Success)
{
return false;
}
}
// hours and minutes
var hours = match.Groups[5].Success ? int.Parse(data.Tokens[match.Groups[5].Index].Value) : 1;
if (hours >= 0 && hours <= 23)
{
// try minutes
var minutes = 0;
if (match.Groups[8].Success)
{
var m = int.Parse(data.Tokens[match.Groups[8].Index].Value);
if (m >= 0 && m <= 59) minutes = m;
}
else if (match.Groups[3].Success && hours > 0)
{
switch (match.Groups[3].Value)
{
case "Q": // quarter
hours--;
minutes = 15;
break;
case "H": // half
hours--;
minutes = 30;
break;
}
}
// create time
var date = new AbstractPeriod();
date.Fix(FixPeriod.TimeUncertain);
if (hours > 12) date.Fix(FixPeriod.Time);
// correct time
if (hours <= 12)
{
var part = "d"; // default
if (match.Groups[9].Success || match.Groups[1].Success)
{
// part of day
part = match.Groups[1].Success ? match.Groups[1].Value : match.Groups[9].Value;
date.Fix(FixPeriod.Time);
}
else
{
date.Fix(FixPeriod.TimeUncertain);
}
switch (part)
{
case "d": // day
if (hours <= 4) hours += 12;
break;
case "v": // evening
if (hours <= 11) hours += 12;
break;
case "g": // night
hours += 12;
break;
}
if (hours == 24) hours = 0;
}
date.Time = new TimeSpan(hours, minutes, 0);
// remove and insert
var toTime = data.Tokens[match.Index];
data.ReplaceTokensByDates(match.Index, match.Length, date);
if (match.Groups[2].Success && match.Groups[2].Value == "t")
{
// return "to" to correct period parsing
data.ReturnTokens(match.Index, "t", toTime);
}
return true;
}
}
return false;
}
}

view raw TimeRecognizer.cs hosted with ❤ by GitHub

आवेदन के क्रम में सभी हैंडलर

प्रणाली मॉड्यूलर है, यह समझा जाता है कि आप हैंडलर्स को जोड़ / निकाल सकते हैं, उनका क्रम बदल सकते हैं, और इसी तरह। मैंने इनमें से 11 को बनाया (आवेदन के क्रम में ऊपर से नीचे तक):

हैंडलर	regex	लाइन उदाहरण
HolidaysRecognizer.cs ¹	`W`	सप्ताह के अंत में , सप्ताहांत
DatesPeriodRecognizer.cs	`f?(0)[ot]0(M\|#)`	26 जनवरी से 27 जनवरी / तारीख
DaysMonthRecognizer.cs	`((0N?)+)(M\|#)`	24 जनवरी, 25, 26 ... और 27 जनवरी / तारीख
MonthRecognizer.cs	`([usxy])?M`	[इन] (अतीत / यह / अगला) मार्च
RelativeDayRecognizer.cs	`[2-6]`	कल से पहले का दिन, कल, आज, परसों, परसों
TimeSpanRecognizer.cs	`(i)?((0?[Ymwdhe]N?)+)([bl])?`	(में) वर्ष और महीने और 2 दिन 4 घंटे 10 मिनट (बाद में / वापस)
YearRecognizer.cs	`(1)Y?\|(0)Y`	[में] 15 साल / 2017 (वर्ष)
RelativeDateRecognizer.cs	`([usxy])([Ymwd])`	[पर / पर] अगले / यह / पिछले वर्ष / माह / सप्ताह / दिन
DayOfWeekRecognizer.cs	`([usxy])?(D)`	[में] (अगले / इस / पिछले) सोमवार
TimeRecognizer.cs	`([rvgd])?([fot])?(Q\|H)?(h\|(0)(h)?)((0)e?)?([rvgd])?`	(w / s / up) (आधा / चौथाई) घंटा / ९ (घंटे) (३० (मिनट)) (सुबह / दिन / शाम / घंटा)
PartOfDayRecognizer.cs	`(@)?f?([ravgdn])f?(@)?`	(तिथि) (w / s) सुबह / दोपहर / शाम / रात (w / s) (तारीख)

¹ "" "" "" " ",

एक साथ सीना

ठीक है, हमने कुछ प्रारंभिक तिथि-समय टोकन को परिभाषित किया है। लेकिन अब हमें किसी भी तरह के सभी प्रकार के टोकन के सभी संयोजनों को ध्यान में रखना चाहिए: उपयोगकर्ता पहले दिन का नाम दे सकता है, और फिर समय का। या महीने और दिन का नाम। यदि वह केवल समय कहता है, तो शायद यह आज के बारे में है, और इसी तरह। ऐसा करने के लिए, हम निर्धारण की अवधारणा के साथ आते हैं।

हमारे मामले में एक सुधार प्रत्येक दिनांक-समय टोकन के अंदर एक बिटमास्क है, जो दर्शाता है कि इसमें कौन से दिनांक और समय तत्व निर्धारित हैं।

 public enum FixPeriod { None = 0, Time = 1, TimeUncertain = 2, Day = 4, Week = 8, Month = 16, Year = 32 }

TimeUncertain उस समय को इंगित करने के लिए प्रतिबद्ध है जिसके बाद एक शोधन का अनुसरण कर सकते हैं, उदाहरण के लिए, शाम / सुबह । इसे सुबह 18 बजे नहीं कहा जा सकता है, लेकिन इसे शाम को 6 बजे कहा जा सकता है, इसलिए संख्या 6 है, जैसा कि यह था, संख्या 18 मुकाबले इसका क्या अर्थ है, इसके बारे में कम "निश्चितता" है।

मुहावरा	निर्धारण	मुखौटा
26 मार्च 2019	वर्ष , महीना , सप्ताह , मांद , vrm1, vrm2	`111100`
26 संख्या	वर्ष, महीना, सप्ताह, मांद , vrm1, vrm2	`000100`
सोमवार	वर्ष, महीना, सप्ताह, मांद , vrm1, vrm2	`000100`
अगले सोमवार	वर्ष , महीना , सप्ताह , मांद , vrm1, vrm2	`111100`
अगले हफ्ते	वर्ष , महीना , सप्ताह , मांद, vrm1, vrm2	`111000`
9 बजे	वर्ष, महीना, सप्ताह, मांद, vrm1 , vrm2	`000010`
रात 9 बजे।	वर्ष, महीना, सप्ताह, मांद, vrm1 , vrm2	`000011`

अगला, हम दो नियमों का उपयोग करेंगे:

यदि तिथियां निकट हैं, और उनके पास आम बिट्स नहीं हैं, तो हम उन्हें एक में मिला देते हैं
यदि तिथियां निकट हैं, और हमने उन्हें संयोजित नहीं किया है, लेकिन उनमें से एक में बिट्स हैं जो दूसरे के पास नहीं है, तो हम बिट्स (और उनके अनुरूप मूल्यों) पर कब्जा करते हैं, जहां वे हैं, जहां वे नहीं हैं, वहां से लेकिन केवल अधिक से अधिक के लिए: अर्थात्, हम एक दिन नहीं ले सकते हैं यदि केवल एक महीना दिया जाता है, लेकिन हम केवल एक दिन निर्धारित होने पर एक महीना ले सकते हैं।

इस प्रकार, यदि उपयोगकर्ता सोमवार को रात 9 बजे बोलता है, तो सोमवार को टोकन, जहां केवल दिन निर्धारित होता है, को 9 बजे टोकन के साथ जोड़ा जाता है, जहां समय निर्धारित होता है। लेकिन अगर वह दिन के 10 और 15 मार्च में कहता है , तो दिन के 15 पर आखिरी टोकन बस मार्च के महीने में पिछले टोकन से ले जाएगा।

संघ तुच्छ है, लेकिन उधार के साथ हम बस आगे बढ़ेंगे। हम उस आधार तिथि को कहेंगे जिसके लिए हम कब्जा करते हैं, और द्वितीयक द्वितीय, जिससे हम कुछ उधार लेना चाहते हैं। फिर हम माध्यमिक तिथि को कॉपी करते हैं और केवल उन बिट्स को छोड़ देते हैं जो आधार के पास नहीं हैं:

 var baseDate = data.Dates[firstIndex]; var secondDate = data.Dates[secondIndex]; var secondCopy = secondDate.CopyOf(); secondCopy.Fixed &= (byte)~baseDate.Fixed;

उदाहरण के लिए, यदि आधार में एक वर्ष था, तो हम नाबालिग की प्रतिलिपि के लिए वर्ष निर्धारण को नहीं छोड़ेंगे (भले ही वह था)। यदि आधार के पास एक महीना नहीं था, लेकिन माध्यमिक के पास है, तो वह द्वितीयक के रूप में प्रतिलिपि के साथ रहेगा। उसके बाद, हम आधार तिथि और माध्यमिक प्रतिलिपि के संयोजन की प्रक्रिया को पूरा करते हैं।

संयुक्त होने पर, हमारे पास एक आधार तिथि और एक अवशोषित भी होती है । हम सबसे बड़ी अवधि (वर्ष) से सबसे छोटे (समय) से ऊपर से नीचे तक जाते हैं। यदि आधार तिथि में कुछ पैरामीटर नहीं है जो अवशोषित है, तो हम इसे अवशोषित एक के आधार में जोड़ते हैं।

Collapse.cs

public static bool CanCollapse(AbstractPeriod basePeriod, AbstractPeriod coverPeriod)
{
if ((basePeriod.Fixed & coverPeriod.Fixed) != 0) return false;
return basePeriod.SpanDirection != -coverPeriod.SpanDirection || basePeriod.SpanDirection == 0;
}
public static bool CollapseTwo(AbstractPeriod basePeriod, AbstractPeriod coverPeriod)
{
if (!CanCollapse(basePeriod, coverPeriod)) return false;
// if span
if (basePeriod.SpanDirection != 0)
{
if (coverPeriod.SpanDirection != 0)
{
// if another date is Span, just add spans together
basePeriod.Span += coverPeriod.Span;
}
}
// take year if it is not here, but is in other date
if (!basePeriod.IsFixed(FixPeriod.Year) && coverPeriod.IsFixed(FixPeriod.Year))
{
basePeriod.Date = new DateTime(coverPeriod.Date.Year, basePeriod.Date.Month, basePeriod.Date.Day);
basePeriod.Fix(FixPeriod.Year);
}
// take month if it is not here, but is in other date
if (!basePeriod.IsFixed(FixPeriod.Month) && coverPeriod.IsFixed(FixPeriod.Month))
{
basePeriod.Date = new DateTime(basePeriod.Date.Year, coverPeriod.Date.Month, basePeriod.Date.Day);
basePeriod.Fix(FixPeriod.Month);
}
// week and day
if (!basePeriod.IsFixed(FixPeriod.Week) && coverPeriod.IsFixed(FixPeriod.Week))
{
// the week is in another date, check where is a day
if (basePeriod.IsFixed(FixPeriod.Day))
{
// set day of week, take date
basePeriod.Date = TakeDayOfWeekFrom(coverPeriod.Date, basePeriod.Date);
basePeriod.Fix(FixPeriod.Week);
}
else if (!coverPeriod.IsFixed(FixPeriod.Day))
{
// only week here, take it by taking a day
basePeriod.Date = new DateTime(basePeriod.Date.Year, basePeriod.Date.Month, coverPeriod.Date.Day);
basePeriod.Fix(FixPeriod.Week);
}
}
else if (basePeriod.IsFixed(FixPeriod.Week) && coverPeriod.IsFixed(FixPeriod.Day))
{
// here is a week, but day of week in other date
basePeriod.Date = TakeDayOfWeekFrom(basePeriod.Date, coverPeriod.Date);
basePeriod.Fix(FixPeriod.Week, FixPeriod.Day);
}
// day
if (!basePeriod.IsFixed(FixPeriod.Day) && coverPeriod.IsFixed(FixPeriod.Day))
{
if (coverPeriod.FixDayOfWeek)
{
// take only day of week from cover
basePeriod.Date = TakeDayOfWeekFrom(
new DateTime(
basePeriod.Date.Year, basePeriod.Date.Month,
basePeriod.IsFixed(FixPeriod.Week) ? basePeriod.Date.Day : 1
),
coverPeriod.Date,
!basePeriod.IsFixed(FixPeriod.Week)
);
basePeriod.Fix(FixPeriod.Week, FixPeriod.Day);
}
else
{
// take day from cover
basePeriod.Date = new DateTime(basePeriod.Date.Year, basePeriod.Date.Month, coverPeriod.Date.Day);
basePeriod.Fix(FixPeriod.Week, FixPeriod.Day);
}
}
// time
var timeGot = false;
if (!basePeriod.IsFixed(FixPeriod.Time) && coverPeriod.IsFixed(FixPeriod.Time))
{
basePeriod.Fix(FixPeriod.Time);
if (!basePeriod.IsFixed(FixPeriod.TimeUncertain))
{
basePeriod.Time = coverPeriod.Time;
}
else
{
if (basePeriod.Time.Hours <= 12 && coverPeriod.Time.Hours > 12)
{
basePeriod.Time += new TimeSpan(12, 0, 0);
}
}
timeGot = true;
}
if (!basePeriod.IsFixed(FixPeriod.TimeUncertain) && coverPeriod.IsFixed(FixPeriod.TimeUncertain))
{
basePeriod.Fix(FixPeriod.TimeUncertain);
if (basePeriod.IsFixed(FixPeriod.Time))
{
// take time from cover, but day part from base
var offset = coverPeriod.Time.Hours <= 12 && basePeriod.Time.Hours > 12 ? 12 : 0;
basePeriod.Time = new TimeSpan(coverPeriod.Time.Hours + offset, coverPeriod.Time.Minutes, 0);
}
else
{
basePeriod.Time = coverPeriod.Time;
timeGot = true;
}
}
// if this date is Span and we just got time from another non-span date, add this time to Span
if (timeGot && basePeriod.SpanDirection != 0 && coverPeriod.SpanDirection == 0)
{
basePeriod.Span += basePeriod.SpanDirection == 1 ? basePeriod.Time : -basePeriod.Time;
}
// set tokens edges
basePeriod.Start = Math.Min(basePeriod.Start, coverPeriod.Start);
basePeriod.End = Math.Max(basePeriod.End, coverPeriod.End);
return true;
}

view raw Collapse.cs hosted with ❤ by GitHub

अलग-अलग, आपको कुछ बारीकियों को ध्यान में रखना होगा:

आधार तिथि एक दिन निश्चित हो सकती है, लेकिन एक सप्ताह नहीं। इस मामले में, आपको अवशोषित तिथि से एक सप्ताह लेने की आवश्यकता है, लेकिन आधार से सप्ताह का दिन।
हालांकि, अगर अवशोषित तिथि का एक दिन निश्चित नहीं होता है, लेकिन एक सप्ताह निर्धारित होता है, तो हमें उस दिन से (यानी, वर्ष + महीना + तिथि) लेने की आवश्यकता होती है और सप्ताह को इस तरह से सेट करना होता है, क्योंकि DateTime ऑब्जेक्ट में कोई अलग इकाई "सप्ताह" नहीं है।
यदि आधार तिथि पर TimeUncertain निर्धारित है, और Time अवशोषित एक पर अवशोषित होता है, और अवशोषित एक पर घंटे की संख्या 12 से अधिक है, जबकि आधार एक कम है, तो आधार में 12 घंटे जोड़ें। क्योंकि आप शाम को 5 से 17 तक नहीं कह सकते। "अनिश्चित" तिथि का समय दिन के एक आधे भाग से नहीं हो सकता है, यदि इसके बगल में "आश्वस्त" तिथि का समय दिन के दूसरे छमाही से है। लोग ऐसा नहीं कहते हैं यदि हमने कहा कि वाक्यांश सुबह 5 बजे से शाम 5 बजे तक है , तो दोनों तिथियों में एक "आत्मविश्वास" समय है, और कोई समस्या नहीं है।

संयोजन के बाद, यदि कुछ तिथियों में रिक्त बिट्स हैं, तो हम उन्हें उपयोगकर्ता की वर्तमान तिथि से मानों के साथ प्रतिस्थापित करते हैं: उदाहरण के लिए, यदि उपयोगकर्ता ने वर्ष का नाम नहीं दिया है, तो हम वर्तमान वर्ष के बारे में बात कर रहे हैं, यदि आपने महीने का नाम नहीं दिया है, तो वर्तमान महीना और इसी तरह। बेशक, किसी भी DateTime ऑब्जेक्ट को लचीलेपन के लिए "वर्तमान तिथि" पैरामीटर को पारित किया जा सकता है।

बैसाखी

पुस्तकालय के सभी क्षणों को इनायत से नहीं सोचा गया था। इसे ठीक से काम करने के लिए, निम्नलिखित बैसाखी को जोड़ा गया था:

टोकन के लिए संयोजन की तारीखें अलग-अलग होती हैं जो "b \ s \ co" से शुरू होती हैं और अलग से टोकन के लिए होती हैं जो "से \ _ पर" शुरू होती हैं। क्योंकि, यदि उपयोगकर्ता ने अवधि का नाम दिया है, तो प्रारंभ तिथि और अंतिम तिथि से टोकन को जोड़ना असंभव है।
मैंने सप्ताह के दिन के लिए एक अलग निर्धारण स्तर शुरू करना शुरू नहीं किया, क्योंकि यह बिल्कुल एक जगह पर आवश्यक है: जहां यह स्पष्ट रूप से सप्ताह के दिन के नाम के साथ एक शब्द द्वारा दिया गया है। इसके लिए झंडा बनाया।
एक अलग रन तारीखों को जोड़ती है जो एक दूसरे से एक निश्चित दूरी पर हैं। यह collapseDistance पैरामीटर द्वारा नियंत्रित किया जाता है, जो डिफ़ॉल्ट रूप से 4 टोकन है। यह है, उदाहरण के लिए, वाक्यांश काम करेगा: कल के बाद का दिन, 12 में एक दोस्त के साथ एक बैठक । लेकिन इसने काम नहीं किया: परसों मैं अपने प्रिय और अद्भुत दोस्त से 12 बजे मिलूंगा ।

परिणाम

आप अपनी परियोजनाओं में पुस्तकालय का उपयोग कर सकते हैं। वह पहले से ही कई विकल्पों के साथ मुकाबला करती है, लेकिन मैं इसे परिष्कृत और परिष्कृत करता हूं। परीक्षणों के साथ अनुरोध का स्वागत है। सामान्य तौर पर, एक परीक्षण के साथ आते हैं जो यथार्थवादी लगता है (जैसा कि लोग जीवन में कहते हैं), लेकिन यह पुस्तकालय को तोड़ देता है।
.NET फेल्ड पर लाइव डेमो भी काम करता है, हालांकि कोड को कथित तौर पर त्रुटियों के साथ रेखांकित किया गया है, लेकिन यह शुरू होता है। कंसोल के निचले भाग में, आप रूसी में वाक्यांशों को दर्ज कर सकते हैं, यह नहीं भूल सकते कि अंकों की संख्या होनी चाहिए।
कंसोल एप्लिकेशन के समान डेमो

लाइव यह इस तरह से निकला:

प्राकृतिक भाषण में दिनांक और समय को पहचानें