public void Evaluate() { var a1 = Fuzz.Ratio("mysmilarstring", "myawfullysimilarstirng"); var a2 = Fuzz.Ratio("mysmilarstring", "mysimilarstring"); var b1 = Fuzz.PartialRatio("similar", "somewhresimlrbetweenthisstring"); var c1 = Fuzz.TokenSortRatio("order words out of", " words out of order"); var c2 = Fuzz.PartialTokenSortRatio("order words out of", " words out of order"); var d1 = Fuzz.TokenSetRatio("fuzzy was a bear", "fuzzy fuzzy fuzzy bear"); var d2 = Fuzz.PartialTokenSetRatio("fuzzy was a bear", "fuzzy fuzzy fuzzy bear"); var e1 = Fuzz.WeightedRatio("The quick brown fox jimps ofver the small lazy dog", "the quick brown fox jumps over the small lazy dog"); var f1 = Fuzz.TokenInitialismRatio("NASA", "National Aeronautics and Space Administration"); var f2 = Fuzz.TokenInitialismRatio("NASA", "National Aeronautics Space Administration"); var f3 = Fuzz.TokenInitialismRatio("NASA", "National Aeronautics Space Administration, Kennedy Space Center, Cape Canaveral, Florida 32899"); var f4 = Fuzz.PartialTokenInitialismRatio("NASA", "National Aeronautics Space Administration, Kennedy Space Center, Cape Canaveral, Florida 32899"); var g1 = Fuzz.TokenAbbreviationRatio("bl 420", "Baseline section 420", PreprocessMode.Full); var g2 = Fuzz.PartialTokenAbbreviationRatio("bl 420", "Baseline section 420", PreprocessMode.Full); var h1 = Process.ExtractOne("cowboys", new[] { "Atlanta Falcons", "New York Jets", "New York Giants", "Dallas Cowboys" }); var h2 = string.Join(", ", Process.ExtractTop("goolge", new[] { "google", "bing", "facebook", "linkedin", "twitter", "googleplus", "bingnews", "plexoogl" }, limit: 3)); var h3 = string.Join(", ", Process.ExtractAll("goolge", new [] { "google", "bing", "facebook", "linkedin", "twitter", "googleplus", "bingnews", "plexoogl" })); var h4 = string.Join(", ", Process.ExtractAll("goolge", new[] { "google", "bing", "facebook", "linkedin", "twitter", "googleplus", "bingnews", "plexoogl" }, cutoff: 40)); var h5 = string.Join(", ", Process.ExtractSorted("goolge", new [] { "google", "bing", "facebook", "linkedin", "twitter", "googleplus", "bingnews", "plexoogl" })); var i1 = Process.ExtractOne("cowboys", new[] { "Atlanta Falcons", "New York Jets", "New York Giants", "Dallas Cowboys" }, s => s, ScorerCache.Get <DefaultRatioScorer>()); var events = new[] { new[] { "chicago cubs vs new york mets", "CitiField", "2011-05-11", "8pm" }, new[] { "new york yankees vs boston red sox", "Fenway Park", "2011-05-11", "8pm" }, new[] { "atlanta braves vs pittsburgh pirates", "PNC Park", "2011-05-11", "8pm" }, }; var query = new[] { "new york mets vs chicago cubs", "CitiField", "2017-03-19", "8pm" }; var best = Process.ExtractOne(query, events, strings => strings[0]); var ratio = ScorerCache.Get <DefaultRatioScorer>(); var partial = ScorerCache.Get <PartialRatioScorer>(); var tokenSet = ScorerCache.Get <TokenSetScorer>(); var partialTokenSet = ScorerCache.Get <PartialTokenSetScorer>(); var tokenSort = ScorerCache.Get <TokenSortScorer>(); var partialTokenSort = ScorerCache.Get <PartialTokenSortScorer>(); var tokenAbbreviation = ScorerCache.Get <TokenAbbreviationScorer>(); var partialTokenAbbreviation = ScorerCache.Get <PartialTokenAbbreviationScorer>(); var weighted = ScorerCache.Get <WeightedRatioScorer>(); }
public void TestWithProcessor() { var events = new[] { new[] { "chicago cubs vs new york mets", "CitiField", "2011-05-11", "8pm" }, new[] { "new york yankees vs boston red sox", "Fenway Park", "2011-05-11", "8pm" }, new[] { "atlanta braves vs pittsburgh pirates", "PNC Park", "2011-05-11", "8pm" }, }; var query = new[] { "new york mets vs chicago cubs", "CitiField", "2017-03-19", "8pm" }; var best = Process.ExtractOne(query, events, SelectFirst, ScorerCache.Get <WeightedRatioScorer>(), 0); Assert.AreEqual(best.Value, events[0]); }
public static IEnumerable <T> SearchItemsUsingTokeniseScorer <T>( IEnumerable <T> items, string?searchString, int matchCutOffScore = MatchCutoffScore, bool stripStopWords = false ) where T : BaseSearchableItem { return(SearchItems( items, searchString, matchCutOffScore, stripStopWords, ScorerCache.Get <PartialTokenSetScorer>() )); }
public static IEnumerable <RoleProfile> FilterRoleProfiles( IEnumerable <RoleProfile> roleProfiles, string?searchString, int minMatchScore, bool stripStopWords ) { if (searchString == null) { return(roleProfiles); } if (stripStopWords) { searchString = CleanSearchedWords(searchString); } var query = new RoleProfile { RoleProfileName = searchString.ToLower() }; if (stripStopWords) { var results = Process.ExtractSorted( query, roleProfiles, roleProfile => roleProfile.RoleProfileName.ToLower(), ScorerCache.Get <DefaultRatioScorer>(), minMatchScore ); return(results.Select(result => result.Value)); } else { var results = Process.ExtractSorted( query, roleProfiles, roleProfile => roleProfile.RoleProfileName.ToLower(), ScorerCache.Get <PartialRatioScorer>(), minMatchScore ); return(results.Select(result => result.Value)); } }
/// <summary> /// Performs a search across all package handlers with the given query. /// </summary> public async Task <List <PackageBase> > SearchAsync(string query) { var packages = new List <PackageBase>(); foreach (var handler in PackageHandlers.Values) { List <PackageBase> results; try { results = await handler.SearchAsync(query); } catch { continue; } // Filter results already in list packages.AddRange(results); } // Fuzzy search to resort by relevance var scorer = ScorerCache.Get <FuzzySharp.SimilarityRatio.Scorer.StrategySensitive.TokenDifferenceScorer>(); return(Process.ExtractSorted(query, packages.Select(p => p.Title + " - " + p.DeveloperName), scorer: scorer) .Select(r => packages.ElementAt(r.Index)).ToList()); }
public static IEnumerable <T> SearchItems <T>( IEnumerable <T> items, string?searchString, int matchCutOffScore = MatchCutoffScore, bool stripStopWords = false, IRatioScorer?scorer = null ) where T : BaseSearchableItem { if (searchString == null) { return(items); } if (stripStopWords) { searchString = CleanSearchedWords(searchString); } var query = Activator.CreateInstance(typeof(T)) as BaseSearchableItem; query !.SearchableName = searchString; var ratioScorer = scorer ?? (stripStopWords ? ScorerCache.Get <DefaultRatioScorer>() : ScorerCache.Get <PartialRatioScorer>()); var results = Process.ExtractAll( (T)query, items, item => string.Join(" ", item.SearchableContent.Where(s => s != null)).ToLower(), ratioScorer, matchCutOffScore ); return(results.Select(result => result.Value)); }
public void TestWithScorer() { var choices = new[] { "new york mets vs chicago cubs", "chicago cubs at new york mets", "atlanta braves vs pittsbugh pirates", "new york yankees vs boston red sox" }; var choicesDict = new Dictionary <int, string> { [1] = "new york mets vs chicago cubs", [2] = "chicago cubs vs chicago white sox", [3] = "philladelphia phillies vs atlanta braves", [4] = "braves vs mets" }; // in this hypothetical example we care about ordering, so we use quick ratio var query = "new york mets at chicago cubs"; // first, as an example, the normal way would select the "more // 'complete' match of choices[1]" var best = Process.ExtractOne(query, choices); Assert.AreEqual(best.Value, choices[1]); // now, use the custom scorer best = Process.ExtractOne(query, choices, null, ScorerCache.Get <DefaultRatioScorer>()); Assert.AreEqual(best.Value, choices[0]); best = Process.ExtractOne(query, choicesDict.Select(k => k.Value)); Assert.AreEqual(best.Value, choicesDict[1]); }
/// <summary> /// Find all alphanumeric tokens in the string and sort /// those tokens and then take ratio of resulting /// joined strings. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int TokenSortRatio(string input1, string input2) { return(ScorerCache.Get <TokenSortScorer>().Score(input1, input2)); }
/// <summary> /// Inconsistent substrings lead to problems in matching. This ratio /// uses a heuristic called "best partial" for when two strings /// are of noticeably different lengths. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static int PartialRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <PartialRatioScorer>().Score(input1, input2, preprocessMode)); }
/// <summary> /// Inconsistent substrings lead to problems in matching. This ratio /// uses a heuristic called "best partial" for when two strings /// are of noticeably different lengths. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int PartialRatio(string input1, string input2) { return(ScorerCache.Get <PartialRatioScorer>().Score(input1, input2)); }
/// <summary> /// Calculates a weighted ratio between the different algorithms for best results /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int WeightedRatio(string input1, string input2) { return(ScorerCache.Get <WeightedRatioScorer>().Score(input1, input2)); }
/// <summary> /// Similarity ratio that attempts to determine whether one strings tokens are an abbreviation /// of the other strings tokens. One string must have all its characters in order in the other string /// to even be considered. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static double TokenAbbreviationRatio(string input1, string input2) { return(ScorerCache.Get <TokenAbbreviationScorer>().Score(input1, input2)); }
public void TestWithCutoff2() { var choices = new[] { "new york mets vs chicago cubs", "chicago cubs at new york mets", "atlanta braves vs pittsbugh pirates", "new york yankees vs boston red sox" }; var query = "new york mets vs chicago cubs"; // Only find 100-score cases var res = Process.ExtractSorted(query, choices, StringPreprocessorFactory.Default, ScorerCache.Get <WeightedRatioScorer>(), 100); Assert.IsTrue(res.Any()); var bestMatch = res.First(); Assert.IsTrue(bestMatch.Value == choices[0]); }
/// <summary> /// Splits the strings into tokens and computes the ratio on those tokens (not the individual chars, /// but the strings themselves) /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static double TokenDifferenceRatio(string input1, string input2) { return(ScorerCache.Get <TokenDifferenceScorer>().Score(input1, input2)); }
/// <summary> /// Calculates a Levenshtein simple ratio between the strings. /// This indicates a measure of similarity /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int Ratio(string input1, string input2) { return(ScorerCache.Get <DefaultRatioScorer>().Score(input1, input2)); }
public void SetUp() { _scorer = ScorerCache.Get <TokenSetScorer>(); _partialScorer = ScorerCache.Get <PartialTokenSetScorer>(); }
/// <summary> /// Splits the strings into tokens and computes the ratio on those tokens (not the individual chars, /// but the strings themselves) /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static double PartialTokenDifferenceRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <PartialTokenDifferenceScorer>().Score(input1, input2, preprocessMode)); }
/// <summary> /// Calculates a weighted ratio between the different algorithms for best results /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static double WeightedRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <WeightedRatioScorer>().Score(input1, input2, preprocessMode)); }
/// <summary> /// Similarity ratio that attempts to determine whether one strings tokens are an abbreviation /// of the other strings tokens. One string must have all its characters in order in the other string /// to even be considered. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static double PartialTokenAbbreviationRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <PartialTokenAbbreviationScorer>().Score(input1, input2, preprocessMode)); }
/// <summary> /// Find all alphanumeric tokens in the string and sort /// those tokens and then take ratio of resulting /// joined strings. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static int TokenSortRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <TokenSortScorer>().Score(input1, input2, preprocessMode)); }
/// <summary> /// Splits longer string into tokens and takes the initialism and compares it to the shorter /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int TokenInitialismRatio(string input1, string input2) { return(ScorerCache.Get <TokenInitialismScorer>().Score(input1, input2)); }
/// <summary> /// Splits the strings into tokens and computes intersections and remainders /// between the tokens of the two strings.A comparison string is then /// built up and is compared using the simple ratio algorithm. /// Useful for strings where words appear redundantly. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static double PartialTokenSetRatio(string input1, string input2) { return(ScorerCache.Get <PartialTokenSetScorer>().Score(input1, input2)); }
/// <summary> /// Splits longer string into tokens and takes the initialism and compares it to the shorter /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static int PartialTokenInitialismRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <PartialTokenInitialismScorer>().Score(input1, input2)); }
public void TestWithCutoff() { var choices = new[] { "new york mets vs chicago cubs", "chicago cubs at new york mets", "atlanta braves vs pittsbugh pirates", "new york yankees vs boston red sox" }; var query = "los angeles dodgers vs san francisco giants"; // in this situation, this is an event that does not exist in the list // we don't want to randomly match to something, so we use a reasonable cutoff var best = Process.ExtractSorted(query, choices, StringPreprocessorFactory.Default, ScorerCache.Get <WeightedRatioScorer>(), 50); Assert.IsTrue(!best.Any()); // .assertIsNone(best) // unittest.TestCase did not have assertIsNone until Python 2.7 // however if we had no cutoff, something would get returned // best = Process.ExtractOne(query, choices) // .assertIsNotNone(best) }
/// <summary> /// Similarity ratio that attempts to determine whether one strings tokens are an abbreviation /// of the other strings tokens. One string must have all its characters in order in the other string /// to even be considered. /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int PartialTokenAbbreviationRatio(string input1, string input2) { return(ScorerCache.Get <PartialTokenAbbreviationScorer>().Score(input1, input2)); }
/// <summary> /// Splits the strings into tokens and computes the ratio on those tokens (not the individual chars, /// but the strings themselves) /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <returns></returns> public static int PartialTokenDifferenceRatio(string input1, string input2) { return(ScorerCache.Get <PartialTokenDifferenceScorer>().Score(input1, input2)); }
/// <summary> /// Splits longer string into tokens and takes the initialism and compares it to the shorter /// </summary> /// <param name="input1"></param> /// <param name="input2"></param> /// <param name="preprocessMode"></param> /// <returns></returns> public static double TokenInitialismRatio(string input1, string input2, PreprocessMode preprocessMode) { return(ScorerCache.Get <TokenInitialismScorer>().Score(input1, input2, preprocessMode)); }