public void FirstCharacter() { var users = MentionExtractor.ExtractMentions("@foo"); Assert.Equal(1, users.Count); Assert.Equal("foo", users[0]); }
private void AddMentions(ChatMessage message) { bool anyMentions = false; foreach (var userName in MentionExtractor.ExtractMentions(message.Content)) { ChatUser mentionedUser = _repository.GetUserByName(userName); // Don't create a mention if // 1. If the mentioned user doesn't exist. // 2. If you mention yourself // 3. If you're mentioned in a private room that you don't have access to if (mentionedUser == null || mentionedUser == message.User || (message.Room.Private && !mentionedUser.AllowedRooms.Contains(message.Room))) { continue; } anyMentions = true; // Mark the notification as read if the user is online bool markAsRead = mentionedUser.Status == (int)UserStatus.Active; _service.AddNotification(mentionedUser, message, markAsRead); } if (anyMentions) { _repository.CommitChanges(); } }
public void TrailingSpace() { var users = MentionExtractor.ExtractMentions("@foo "); Assert.Equal(1, users.Count); Assert.Equal("foo", users[0]); }
public void Multiple() { var users = MentionExtractor.ExtractMentions("@foo @bar"); Assert.Equal(2, users.Count); Assert.Equal("foo", users[0]); Assert.Equal("bar", users[1]); }
public List <EntityInfo> ExtractMentionsOrLists(string text) { var result = new List <EntityInfo>(); if (!string.IsNullOrEmpty(text)) { MentionExtractor.Extract(text, true, result); } return(result); }
public List <EntityInfo> ExtractMentionedScreenNames(string text) { var result = new List <EntityInfo>(); if (!string.IsNullOrEmpty(text)) { MentionExtractor.Extract(text, false, result); } return(result); }
public List <EntityInfo> ExtractEntities(string text) { var result = new List <EntityInfo>(); if (!string.IsNullOrEmpty(text)) { UrlExtractor.Extract(text, this.ExtractsUrlWithoutProtocol, this._tldDictionary, this._longestTldLength, this._shortestTldLength, result); HashtagExtractor.Extract(text, result); MentionExtractor.Extract(text, true, result); CashtagExtractor.Extract(text, result); RemoveOverlappingEntities(result); } return(result); }
private void AddMentions(ChatMessage message) { var mentionedUsers = new List <ChatUser>(); foreach (var userName in MentionExtractor.ExtractMentions(message.Content)) { ChatUser mentionedUser = _repository.GetUserByName(userName); // Don't create a mention if // 1. If the mentioned user doesn't exist. // 2. If you mention yourself // 3. If you're mentioned in a private room that you don't have access to // 4. You've already been mentioned in this message if (mentionedUser == null || mentionedUser == message.User || (message.Room.Private && !mentionedUser.AllowedRooms.Contains(message.Room)) || mentionedUsers.Contains(mentionedUser)) { continue; } // mark as read if ALL of the following // 1. user is not offline // 2. user is not AFK // 3. user has been active within the last 10 minutes // 4. user is currently in the room bool markAsRead = mentionedUser.Status != (int)UserStatus.Offline && !mentionedUser.IsAfk && (DateTimeOffset.UtcNow - mentionedUser.LastActivity) < TimeSpan.FromMinutes(10) && _repository.IsUserInRoom(_cache, mentionedUser, message.Room); _service.AddNotification(mentionedUser, message, message.Room, markAsRead); mentionedUsers.Add(mentionedUser); } if (mentionedUsers.Count > 0) { _repository.CommitChanges(); } foreach (var user in mentionedUsers) { UpdateUnreadMentions(user); } }
public DeterministicCorefAnnotator(Properties props) { // for backward compatibility try { corefSystem = new SieveCoreferenceSystem(props); mentionExtractor = new MentionExtractor(corefSystem.Dictionaries(), corefSystem.Semantics()); OldFormat = bool.Parse(props.GetProperty("oldCorefFormat", "false")); allowReparsing = PropertiesUtils.GetBool(props, Constants.AllowReparsingProp, Constants.AllowReparsing); // unless custom mention detection is set, just use the default coref mention detector performMentionDetection = !PropertiesUtils.GetBool(props, "dcoref.useCustomMentionDetection", false); if (performMentionDetection) { mentionAnnotator = new CorefMentionAnnotator(props); } } catch (Exception e) { log.Error("cannot create DeterministicCorefAnnotator!"); log.Error(e); throw new Exception(e); } }
public void Nothing() { var users = MentionExtractor.ExtractMentions("@@@@@"); Assert.Equal(0, users.Count); }
public virtual void Annotate(Annotation annotation) { // temporarily set the primary named entity tag to the coarse tag SetNamedEntityTagGranularity(annotation, "coarse"); if (performMentionDetection) { mentionAnnotator.Annotate(annotation); } try { IList <Tree> trees = new List <Tree>(); IList <IList <CoreLabel> > sentences = new List <IList <CoreLabel> >(); // extract trees and sentence words // we are only supporting the new annotation standard for this Annotator! bool hasSpeakerAnnotations = false; if (annotation.ContainsKey(typeof(CoreAnnotations.SentencesAnnotation))) { // int sentNum = 0; foreach (ICoreMap sentence in annotation.Get(typeof(CoreAnnotations.SentencesAnnotation))) { IList <CoreLabel> tokens = sentence.Get(typeof(CoreAnnotations.TokensAnnotation)); sentences.Add(tokens); Tree tree = sentence.Get(typeof(TreeCoreAnnotations.TreeAnnotation)); trees.Add(tree); SemanticGraph dependencies = SemanticGraphFactory.MakeFromTree(tree, SemanticGraphFactory.Mode.Collapsed, GrammaticalStructure.Extras.None, null, true); // locking here is crucial for correct threading! sentence.Set(typeof(SemanticGraphCoreAnnotations.AlternativeDependenciesAnnotation), dependencies); if (!hasSpeakerAnnotations) { // check for speaker annotations foreach (CoreLabel t in tokens) { if (t.Get(typeof(CoreAnnotations.SpeakerAnnotation)) != null) { hasSpeakerAnnotations = true; break; } } } MentionExtractor.MergeLabels(tree, tokens); MentionExtractor.InitializeUtterance(tokens); } } else { log.Error("this coreference resolution system requires SentencesAnnotation!"); return; } if (hasSpeakerAnnotations) { annotation.Set(typeof(CoreAnnotations.UseMarkedDiscourseAnnotation), true); } // extract all possible mentions // this is created for each new annotation because it is not threadsafe RuleBasedCorefMentionFinder finder = new RuleBasedCorefMentionFinder(allowReparsing); IList <IList <Mention> > allUnprocessedMentions = finder.ExtractPredictedMentions(annotation, 0, corefSystem.Dictionaries()); // add the relevant info to mentions and order them for coref Document document = mentionExtractor.Arrange(annotation, sentences, trees, allUnprocessedMentions); IList <IList <Mention> > orderedMentions = document.GetOrderedMentions(); IDictionary <int, CorefChain> result = corefSystem.CorefReturnHybridOutput(document); annotation.Set(typeof(CorefCoreAnnotations.CorefChainAnnotation), result); if (OldFormat) { IDictionary <int, CorefChain> oldResult = corefSystem.Coref(document); AddObsoleteCoreferenceAnnotations(annotation, orderedMentions, oldResult); } } catch (Exception e) { throw; } catch (Exception e) { throw new Exception(e); } finally { // restore to the fine-grained SetNamedEntityTagGranularity(annotation, "fine"); } }