public StereoToMonoConverter(ISampleStream <float> source) : base(source)
{
if (source.Format.Channels != 2)
{
throw new ArgumentException("Source must provide stereo data.", nameof(source));
}
Format = new Format(1, source.Format.SampleRate);
}
public IEnumerable <DB.Tweet> Run()
{
tweets = new BlockingCollection <DB.Tweet>();
stream = Stream.CreateSampleStream(credentials);
stream.TweetReceived += (s, e) => AddTweet(e);
stream.StartStreamAsync();
return(tweets.GetConsumingEnumerable());
}
/// <summary>Initializes a new instance of the <see cref="SampleSourceWrapper" /> class.</summary>
/// <param name="source">The sample source.</param>
public SampleSourceWrapper(ISampleStream source)
{
this.source = source;
format = new WaveFormat(
source.Format.SamplingRate,
32,
source.Format.Channels * (source.Format.IsComplex ? 2 : 1),
AudioEncoding.IeeeFloat);
}
/// <summary>
/// Create a new <see cref="LoopStream{T}"/>. <see cref="Enable"/> initializes to <code>true</code>.
/// </summary>
/// <param name="source">The source stream to read from.</param>
/// <exception cref="ArgumentException">If the give source stream is not seekable.</exception>
public LoopStream(ISampleStream <T> source) : base(source)
{
if (!source.IsStatic)
{
throw new ArgumentException("Looped source must be seekable.", nameof(source));
}
Enable = true;
}
public TwitterStreamProcessor(ITwitterCredentials credentials, ITweetFilter tweetFilter, ITweetTrim tweetTrimmer, IHashPairGenerator hashPairGenerator, IPipelineRepository repo)
{
_credentials = credentials;
_tweetFilter = tweetFilter;
_tweetTrimmer = tweetTrimmer;
_hashPairGenerator = hashPairGenerator;
_repo = repo;
_stream = Stream.CreateSampleStream(_credentials);
_stream.AddTweetLanguageFilter(LanguageFilter.English);
}
//IIqProcessor
/// <summary>Initializes the resampler for processing data from the specified source.</summary>
/// <param name="source">The data source.</param>
public void Initialize(ISampleStream source)
{
Format = new SignalFormat(source.Format);
Format.SamplingRate = outputSamplingRate;
var wrapper = new SampleSourceWrapper(source).ToWaveSource();
dmo = new DmoResampler(wrapper, outputSamplingRate);
dmo.Quality = Quality;
resampler = dmo.ToSampleSource();
}
public void Stop()
{
_Context?.Dispose();
// Set the target to the completed state to signal to the consumer that no more data will be available.
_TargetBuffer?.Complete();
_Stream?.StopStream();
_Stream = null;
Library.WriteErrorLog("Tweet streamer stoped (.Stop()).");
}
public async Task Run()
{
System.Console.WriteLine("Run was called.");
var twitterClient = _container.Resolve(typeof(TwitterClient)).AsInstanceOf <TwitterClient>();
_sampleStream = twitterClient.Streams.CreateSampleStream();
_sampleStream.TweetReceived += SampleStreamOnTweetReceived;
_sampleStream.StartAsync();
System.Console.WriteLine("Run Finished.");
}
static Startup()
{
Auth.ApplicationCredentials = new TwitterCredentials(ConfigurationManager.AppSettings["consumerKey"],
ConfigurationManager.AppSettings["consumerSecret"],
ConfigurationManager.AppSettings["accessToken"], ConfigurationManager.AppSettings["accessTokenSecret"]);
tStream = Stream.CreateSampleStream();
tStream.AddTweetLanguageFilter(Language.English);
tStream.TweetReceived += tStream_TweetReceived;
tStream.StreamStopped += tStream_StreamStopped;
tStream.StallWarnings = true;
tStream.StartStreamAsync();
}
private void Produce()
{
_Stream = Stream.CreateSampleStream();
_Stream.TweetReceived += (object sender, Tweetinvi.Events.TweetReceivedEventArgs e) =>
{
_TargetBuffer.Post(e.Tweet);
};
_Stream.AddTweetLanguageFilter(LanguageFilter.English);
_Stream.StartStreamAsync();
}
public void Start()
{
_stream = Stream.CreateSampleStream();
_stream.Credentials = _credentials;
_hubContext.Clients.All.log("Message from Server: Sample stream created");
_stream.TweetReceived += (sender, args) =>
{
var tweet = new TweetViewModel(args.Tweet);
_hubContext.Clients.All.broadcastTweet(tweet);
};
_stream.StartStreamAsync();
}
public void Start()
{
_stream = Stream.CreateSampleStream();
_stream.Credentials = _credentials;
_hubContext.Clients.All.log("Message from Server: Sample stream created");
_stream.TweetReceived += (sender, args) =>
{
var tweet = new TweetViewModel(args.Tweet);
_hubContext.Clients.All.broadcastTweet(tweet);
};
_stream.StartStreamAsync();
}
/// <summary>
/// Producer. Streams tweets from twiter sample stream and post for consumer to process.
/// </summary>
/// <param name="target"></param>
public void Produce(ITargetBlock <ITweet> target)
{
// Create Twitter sample stream (1% of all public tweets)
_Stream = Stream.CreateSampleStream();
_Stream.TweetReceived += (object sender, Tweetinvi.Events.TweetReceivedEventArgs e) => {
target.Post(e.Tweet);
};
_Stream.AddTweetLanguageFilter(LanguageFilter.English);
// Begin streaming from twitter sample stream
_Stream.StartStream();
// Set the target to the completed state to signal to the consumer
// that no more data will be available
target.Complete();
}
static void Main(string[] arg)
{
Auth.SetUserCredentials("", "", "", "");//Enter your Twitter Credentials
ExceptionHandler.SwallowWebExceptions = false;
_sampleStream = Stream.CreateSampleStream(Auth.Credentials);
_sampleStream.AddTweetLanguageFilter(Tweetinvi.Core.Enum.Language.English);
_sampleStream.TweetReceived += (sender, args) =>
{
SqlInsert(args.Tweet);
};
_sampleStream.StreamStarted += (sender, args) =>
{ };
_sampleStream.StreamStopped += (sender, args) =>
{
var exception = args.Exception;
var disconnectMessage = args.DisconnectMessage;
if (exception != null)
{
Console.WriteLine(exception.ToString());
}
if (disconnectMessage != null)
{
Console.WriteLine(disconnectMessage.ToString());
}
};
while (true)
{
try
{
new Program().RunTwitter().Wait();
}
catch (AggregateException ex)
{
foreach (var e in ex.InnerExceptions)
{
Console.WriteLine("Error: " + e.Message);
}
}
}
}
public void createSampleStreamForBloombergFilter()
{
bloombergTupels = new ConcurrentBag <Tupel>();
IAuthenticatedUser user = setAuthentication();
stream = Stream.CreateSampleStream();
Filter <string> bloomfilter = new Filter <string>(10000);
bloomfilter.Add("United Stats");
bloomfilter.Add("Italy");
bloomfilter.Add("Trump");
bloomfilter.Add("Hillary");
bloomfilter.Add("Holiday");
bloomfilter.Add("Beach");
bloomfilter.Add("Election");
bloomfilter.Add("trump");
bloomfilter.Add("hillary");
bloomfilter.Add("holiday");
bloomfilter.Add("eeach");
bloomfilter.Add("election");
stream.TweetReceived += (sender, args) =>
{
bloombergTweets++;
if (args.Tweet.Hashtags.Count > 0)
{
bloombergTweetsWithPlace++;
// if (bloomfilter.Contains(args.Tweet.Place.Country))
// {
foreach (IHashtagEntity hashtag in args.Tweet.Hashtags)
{
Console.WriteLine(hashtag.Text);
if (bloomfilter.Contains(hashtag.Text))
{
bloombergTupels.Add(new Tupel(args.Tweet.CreatedBy.Name, args.Tweet.CreatedAt.ToLongTimeString()));
}
}
// }
}
};
stream.StartStream();
}
public void createSampleStreamForSampling()
{
samplingTupels = new ConcurrentBag <Tupel>();
IAuthenticatedUser user = setAuthentication();
stream = Stream.CreateSampleStream();
stream.TweetReceived += (sender, args) =>
{
samplingTweets++;
if (args.Tweet.Place != null)
{
samplingTweetsWithPlace++;
if (hashString(args.Tweet.Place.Name) % 10 == 0)
{
samplingTupels.Add(new Tupel(args.Tweet.CreatedBy.Name, args.Tweet.CreatedAt.ToLongTimeString()));
}
}
};
stream.StartStream();
}
public void createSampleStream()
{
Auth.SetUserCredentials("HK6dYDYaZ91hGHA7uQoi1oWIO", //Consumerkey
"8uMf9m1UTx2ST9bhzd0Ow9BLhLmqrU2GLRdnU2seWSYTKm2trH", //Consumer Secret
"793479816209174528-eqb2G4BCyhTb32KtNh1BnLdArWcDgiU", //Access Token
"oaO4hXOeWXhXuyxJYY2RkE7ffwrdh7N8W3CAmh93CVykw" //Acces Token Secret
);
var user = User.GetAuthenticatedUser();
stream = Stream.CreateSampleStream();
stream.TweetReceived += (sender, args) =>
{
i++;
if (args.Tweet.Hashtags.Count > 0)
{
hashtags.Add(args.Tweet.Hashtags[0].Text);
//Console.WriteLine(args.Tweet.Hashtags[0].Text);
}
};
stream.StartStream();
}
/// <summary>
/// Create a <see cref="SampleStreamMemory{T}"/> instance.
/// </summary>
/// <param name="stream">Stream to listen to.</param>
/// <param name="capacity">Capacity of the <see cref="Buffer"/>.</param>
public SampleStreamMemory(ISampleStream<T> stream, int capacity)
{
Buffer = new CircularBuffer<T>(capacity);
Stream = stream;
stream.SamplesRead += OnSamplesRead;
}
public IFluentTime IfTrue(ISampleStream stream)
{
ifStream = stream;
return CreateTime();
}
public IFluentOperatingTime UsingCondition(ISampleStream usingConditionStream)
{
conditionStream = usingConditionStream;
return this;
}
public IFluentOpcHdaMonitor UpdateEvery(ISampleStream timerStream)
{
// Expression sampleStream is used to register the dependency
return this;
}
public static void CreateCommands()
{
var CService = _client.GetService <CommandService>();
ISampleStream SampleStream = Tweetinvi.Stream.CreateSampleStream();
IFilteredStream FilteredStream = Tweetinvi.Stream.CreateFilteredStream();
CService.CreateCommand("State")
.Alias("StreamState", "SS")
.Description("Displays whether the streams are running or not")
.Do(async(e) =>
{
await e.Channel.SendMessage($"Filtered Stream: {FilteredStream.StreamState} {Environment.NewLine}Sample Stream: {SampleStream.StreamState}");
});
CService.CreateCommand("PurgeStreams")
.Alias("PS", "Purge")
.Description("Purges all running streams")
.Do(async(e) =>
{
SampleStream.StopStream();
FilteredStream.StopStream();
FilteredStream.ClearTracks();
await e.Channel.SendMessage($"```Sample Stream: {SampleStream.StreamState} {Environment.NewLine}Filtered Stream: {FilteredStream.StreamState}```");
});
CService.CreateCommand("Sample")
.Description("Initializes a socalled sample stream but instead of 1% its specified with an amount of random tweets, Neat!")
.Parameter("Tweets", ParameterType.Unparsed)
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("Tweets"), @"-?\d+(\.\d+)?"))
{
int Tweets = Convert.ToInt32(e.GetArg("Tweets"));
await e.Channel.SendMessage("Transmitting " + e.GetArg("Tweets") + " Tweets");
Console.WriteLine(Tweetinvi.User.GetAuthenticatedUser());
int i = 0;
SampleStream.TweetReceived += (sender, args) =>
{
if (i < Tweets)
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
i++;
}
else
{
SampleStream.StopStream();
}
};
SampleStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage($"```Stream ended { Environment.NewLine }Exception: { Exception } { Environment.NewLine }Disconnect message: { DisconnectMessage }```");
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("Error Invalid input");
}
});
CService.CreateCommand("Track")
.Description("Tracks a twitter User Either from their ID or Handle")
.Parameter("User", ParameterType.Unparsed)
.Description("Tracks a Twitter User")
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("User"), @"-?\d+(\.\d+)?"))
{
long User = Convert.ToInt64(e.GetArg("User"));
IUser Target = Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User")));
await e.Channel.SendMessage($"Tracking { Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User"))) }");
FilteredStream.AddFollow(User);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
e.Channel.SendMessage(Target + " " + args.Tweet);
};
FilteredStream.StreamStopped += (sender, args) =>
{
e.Channel.SendMessage("Filtered Stream Ended");
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
else
{
var Target = Tweetinvi.User.GetUserFromScreenName(e.GetArg("User"));
await e.Channel.SendMessage($"Tracking { Tweetinvi.User.GetUserFromScreenName(e.GetArg("User")) }");
FilteredStream.AddFollow(Target);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
Console.WriteLine("Found Tweet");
e.Channel.SendMessage($"{ e.GetArg("User") } Tweeted { args.Tweet }");
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
});
}
protected StreamConverterBase(ISampleStream <TIn> source, int capacity = 0)
: base(source)
{
Buffer = new TIn[capacity];
}
public IFluentOperatingTime UpdateEvery(ISampleStream timerStream)
{
// Expression timerStream is used to register the dependency
return this;
}
public void CreateCommands()
{
var CService = _client.GetService <CommandService>();
IFilteredStream FilteredStream = Tweetinvi.Stream.CreateFilteredStream();
ISampleStream SampleStream = Tweetinvi.Stream.CreateSampleStream();
CService.CreateCommand("StreamState")
.Description("Gets the states of the streams")
.Do(async(e) =>
{
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("PurgeStreams")
.Alias("Kill", "Stop", "PS")
.Description("Hopefully stops the stream")
.Do(async(e) =>
{
FilteredStream.StopStream();
SampleStream.StopStream();
FilteredStream.ClearTracks();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("StopSampleStream")
.Description("Stops all sample streams")
.Do(async(e) =>
{
SampleStream.StopStream();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("StopFilteredStream")
.Description("Stops all Filtered streams")
.Do(async(e) =>
{
FilteredStream.StopStream();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("Track")
.Description("Tracks a twitter User Either from their ID or Handle")
.Parameter("User", ParameterType.Unparsed)
.Description("Tracks a Twitter User")
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("User"), @"-?\d+(\.\d+)?"))
{
long User = Convert.ToInt64(e.GetArg("User"));
IUser Target = Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User")));
await e.Channel.SendMessage("Tracking " + Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User"))));
FilteredStream.AddFollow(User);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
e.Channel.SendMessage(Target + " " + args.Tweet);
};
FilteredStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage("Filtered stream ended exception: " + Exception + " Disconnect message: " + DisconnectMessage);
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
else
{
var Target = Tweetinvi.User.GetUserFromScreenName(e.GetArg("User"));
await e.Channel.SendMessage("Tracking " + Tweetinvi.User.GetUserFromScreenName(e.GetArg("User")));
FilteredStream.AddFollow(Target);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
Console.WriteLine("Found Tweet");
e.Channel.SendMessage(e.GetArg("User") + " Tweeted " + args.Tweet);
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
});
CService.CreateCommand("Spam")
.Alias("Havoc", "Anton", "Cancer")
.Description("Initializes a socalled sample stream which returns 1% of all public tweets Discord will not show them all because of RateLimits.")
.Do(async(e) =>
{
if (e.User.ServerPermissions.ManageServer == true)
{
SampleStream.TweetReceived += (sender, args) =>
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("ERROR most likely you do not have sufficient permissions");
}
});
CService.CreateCommand("Sample")
.Description("Initializes a socalled sample stream but instead of 1% its specified with an amount of random tweets, Neat!")
.Parameter("Tweets", ParameterType.Unparsed)
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("Tweets"), @"-?\d+(\.\d+)?"))
{
int Tweets = Convert.ToInt32(e.GetArg("Tweets"));
await e.Channel.SendMessage("Transmitting " + e.GetArg("Tweets") + " Tweets");
int i = 0;
SampleStream.TweetReceived += (sender, args) =>
{
i++;
if (i < Tweets)
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
}
else
{
SampleStream.StopStream();
}
};
FilteredStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage("Filtered stream ended exception: " + Exception + " Disconnect message: " + DisconnectMessage);
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("Error Invalid input");
}
});
}
private bool TryEvaluateSampleAt(ISampleStream stream, DateTime time, out bool result, out DateTime timeStamp)
{
bool returnValue = false;
result = false;
timeStamp = DateTime.MinValue;
ISample sample = stream[time];
if (sample != null)
{
if (sample.IsGood)
{
try
{
bool value = Convert.ToBoolean(sample.Value);
timeStamp = sample.TimeStamp;
result = value;
returnValue = true;
}
catch (Exception)
{
// swallow exceptions
}
}
}
return returnValue;
}
/// <summary>
/// Create a new SinkBase.
/// </summary>
/// <param name="source">Source for the sink.</param>
protected StreamConsumerBase(ISampleStream <T> source)
{
Source = source;
}
/// <summary>
/// References the stream dependency for triggering calculations
/// </summary>
/// <param name="sampleStream">The sample stream.</param>
/// <returns></returns>
public IFluentCalendar WithDependency(ISampleStream sampleStream)
{
// Expression sampleStream is used to register the dependency
return this;
}
