protected void Page_Load(object sender, EventArgs e)
{
var query = new QueryInput
{
Text = new TextInput
{
Text = "cc",
LanguageCode = "en-us"
}
};
var sessionId = "SomeUniqueId";
var agent = "test5";
var creds = GoogleCredential.FromJson(@"D:/test5.json");
var channel = new Grpc.Core.Channel(SessionsClient.DefaultEndpoint.Host,
creds.ToChannelCredentials());
var client = SessionsClient.Create(channel);
var dialogFlow = client.DetectIntent(
new SessionName(agent, sessionId),
query
);
channel.ShutdownAsync();
}
public List <string> getMatches(string filePath)
{
string path = MapPath("~/My Project 25680-6d24c8bb9131.json");
//var credential = GoogleCredential.FromFile(path);
//Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", "");
var output = new List <string>();
//var client = ImageAnnotatorClient.Create(credential);
GoogleCredential googleCredential;
using (Stream m = new FileStream(path, FileMode.Open))
googleCredential = GoogleCredential.FromStream(m);
var channel = new Grpc.Core.Channel(ImageAnnotatorClient.DefaultEndpoint.Host,
googleCredential.ToChannelCredentials());
var client = ImageAnnotatorClient.Create(channel);
var image = Image.FromFile(filePath);
var response = client.DetectLogos(image);
foreach (var annotation in response)
{
if (annotation.Description != null)
{
output.Add(annotation.Description);
}
}
return(output);
}
public static Dictionary <string, LanguageItem> ListVoiceLanguages(Grpc.Core.Channel channel)
{
TextToSpeechClient client = TextToSpeechClient.Create(channel);
Dictionary <string, LanguageItem> languages = new Dictionary <string, LanguageItem>();
// Performs the list voices request
var response = client.ListVoices(new ListVoicesRequest {
});
foreach (Voice voice in response.Voices)
{
foreach (var languageCode in voice.LanguageCodes)
{
if (!languages.ContainsKey(languageCode.ToString()))
{
string displayName = languageCode + " | " + new CultureInfo($"{languageCode}").DisplayName;
LanguageItem newItem = new LanguageItem
{
Text = displayName,
Id = languageCode
};
languages.Add(languageCode, newItem);
}
}
}
return(languages);
}
public static List <VoiceItem> ListVoices(Grpc.Core.Channel channel)
{
TextToSpeechClient client = TextToSpeechClient.Create(channel);
// Performs the list voices request
var response = client.ListVoices(new ListVoicesRequest
{
});
List <VoiceItem> voices = new List <VoiceItem>();
foreach (Voice voice in response.Voices)
{
foreach (var languageCode in voice.LanguageCodes)
{
VoiceItem voiceItem = new VoiceItem
{
Name = voice.Name,
Gender = voice.SsmlGender.ToString(),
Language = languageCode,
};
voices.Add(voiceItem);
}
}
return(voices);
}
public static string Recognize(string imagePath)
{
if (credential == null)
{
var googleCredsPath = System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
? @"C:\mydev\My Project-77101559a6d3.json"
: "/Users/slav/Downloads/My Project-d1092d64586a.json";
credential = GoogleCredential.FromFile(googleCredsPath)
.CreateScoped(ImageAnnotatorClient.DefaultScopes);
channel = new Grpc.Core.Channel(
ImageAnnotatorClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = ImageAnnotatorClient.Create(channel);
}
var image = Image.FromFile(imagePath);
var response = client.DetectText(image);
int count = response.Count;
foreach (var annotation in response)
{
if (annotation.Description != null)
{
return(annotation.Description);
}
}
return(null);
}
public async Task <string> ConvertSpeechFileToText(string fileName)
{
string URI = "gs://eznotes-user-files/" + fileName;
// Create credential from secret file
var credential = GoogleCredential.FromFile(this.keypath)
.CreateScoped(SpeechClient.DefaultScopes);
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var speech = SpeechClient.Create(channel);
var longOperation = await speech.LongRunningRecognizeAsync(new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en-US",
EnableWordTimeOffsets = true,
Model = "phone_call",
EnableSpeakerDiarization = true,
EnableAutomaticPunctuation = true,
UseEnhanced = true
}, RecognitionAudio.FromStorageUri(URI));
longOperation = await longOperation.PollUntilCompletedAsync();
string response = JsonConvert.SerializeObject(longOperation.Result.Results);
return(response);
}
public async Task <IActionResult> sendtext(string text, string sessionId)
{
var result = new RequestResult();
try
{
var query = new QueryInput {
Text = new TextInput {
Text = text, LanguageCode = "ru-ru"
}
};
var agent = "small-talk-1-cdboby";
var creds = GoogleCredential.FromFile($"{_env.WebRootPath}\\DFCredits.json");
var channel = new Grpc.Core.Channel(SessionsClient.DefaultEndpoint.Host, creds.ToChannelCredentials());
var client = SessionsClient.Create(channel);
var dialogFlow = await client.DetectIntentAsync(new SessionName(agent, sessionId), query);
await channel.ShutdownAsync();
result.IsSuccess = true;
result.Data = string.IsNullOrEmpty(dialogFlow?.QueryResult?.FulfillmentText) ? GetRandomDontKnow() : dialogFlow.QueryResult.FulfillmentText;
}
catch (Exception err)
{
result.IsSuccess = false;
result.Data = "Упс... что-то пошло не так...";
result.Error = $"Ошбика: {err.Message}";
}
return(new JsonResult(result));
}
/// <summary>
/// Receive robot output data from HEL
/// </summary>
private async void ReceiveData()
{
var conn = new Grpc.Core.Channel(EmulatorManager.DEFAULT_HOST + ":" + ((EmulatorManager.programType == UserProgram.Type.JAVA) ? DEFAULT_JAVA_PORT : DEFAULT_NATIVE_PORT), Grpc.Core.ChannelCredentials.Insecure);
var client = new EmulationReader.EmulationReaderClient(conn);
while (EmulatorManager.IsTryingToRunRobotCode() && Instance && isConnectionOpen) // Run while robot code is running or until the object stops existing
{
try
{
using (var call = client.RobotOutputs(new RobotOutputsRequest {
Api = API_VERSION,
TargetPlatform = EmulatorManager.programType == UserProgram.Type.JAVA ? TargetPlatform.Java : TargetPlatform.Native,
}))
{
while (await call.ResponseStream.MoveNext())
{
receiverConnected = true;
EmulatedRoboRIO.RobotOutputs = call.ResponseStream.Current.OutputData;
// Debug.Log("Received " + EmulatedRoboRIO.RobotOutputs);
}
}
}
catch (Exception)
{
receiverConnected = false;
await Task.Delay(ERROR_DELAY); // ms
}
}
receiverConnected = false;
isConnectionOpen = false;
}
public ActionResult JSonuc([FromBody] byte[] file)
{
try
{/*
* file.
* string path = Path.Combine(Server.MapPath("~/App_Data/Images"),
* Path.GetFileName(file.FileName));
* file.SaveAs(path);*/
var credential = GoogleCredential.FromFile("C:\\Shelff-4e74dc12eb0d.json")
.CreateScoped(ImageAnnotatorClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
ImageAnnotatorClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = ImageAnnotatorClient.Create(channel);
var image = Google.Cloud.Vision.V1.Image.FromBytes(file);
Vision.Sonuclar sonuc = new Vision.Sonuclar {
LabelAnnotations = client.DetectLabels(image), TextAnnotations = client.DetectText(image), SafeSearchAnnotation = client.DetectSafeSearch(image), ImagePropertiesAnnotation = client.DetectImageProperties(image), CropHintsAnnotation = client.DetectCropHints(image), FullTextAnnotation = client.DetectText(image), WebDetection = client.DetectWebInformation(image)
};
return(Json(sonuc));
}
catch (Exception ex)
{
return(NotFound(ex));
}
}
public GoogleCloudLoggingSink(GoogleCloudLoggingSinkOptions sinkOptions, MessageTemplateTextFormatter messageTemplateTextFormatter, int batchSizeLimit, TimeSpan period)
: base(batchSizeLimit, period)
{
if (sinkOptions.GoogleCredentialJson == null)
{
_client = LoggingServiceV2Client.Create();
}
else
{
var googleCredential = GoogleCredential.FromJson(sinkOptions.GoogleCredentialJson);
var channel = new Grpc.Core.Channel(LoggingServiceV2Client.DefaultEndpoint.Host, googleCredential.ToChannelCredentials());
_client = LoggingServiceV2Client.Create(channel);
}
_sinkOptions = sinkOptions;
_resource = new MonitoredResource {
Type = sinkOptions.ResourceType
};
foreach (var kvp in _sinkOptions.ResourceLabels)
{
_resource.Labels[kvp.Key] = kvp.Value;
}
var ln = new LogName(sinkOptions.ProjectId, sinkOptions.LogName);
_logName = ln.ToString();
_logNameToWrite = LogNameOneof.From(ln);
_messageTemplateTextFormatter = messageTemplateTextFormatter;
}
public GoogleCloudLoggingSink(GoogleCloudLoggingSinkOptions sinkOptions, MessageTemplateTextFormatter messageTemplateTextFormatter, int batchSizeLimit, TimeSpan period)
: base(batchSizeLimit, period)
{
// logging client for google cloud apis
// requires extra setup if credentials are passed as raw json text
if (sinkOptions.GoogleCredentialJson == null)
{
_client = LoggingServiceV2Client.Create();
}
else
{
var googleCredential = GoogleCredential.FromJson(sinkOptions.GoogleCredentialJson);
var channel = new Grpc.Core.Channel(LoggingServiceV2Client.DefaultEndpoint.Host, googleCredential.ToChannelCredentials());
_client = LoggingServiceV2Client.Create(channel);
}
_sinkOptions = sinkOptions;
_logFormatter = new LogFormatter(_sinkOptions, messageTemplateTextFormatter);
_resource = new MonitoredResource {
Type = sinkOptions.ResourceType
};
foreach (var kvp in _sinkOptions.ResourceLabels)
{
_resource.Labels[kvp.Key] = kvp.Value;
}
var ln = new LogName(sinkOptions.ProjectId, sinkOptions.LogName);
_logName = ln.ToString();
_logNameToWrite = LogNameOneof.From(ln);
_serviceNameAvailable = !String.IsNullOrWhiteSpace(_sinkOptions.ServiceName);
}
private FirestoreDb CreateDb()
{
var builder = new ConfigurationBuilder();
var configuration = builder
.AddEnvironmentVariables()
.AddJsonFile(Path.Combine(Directory.GetCurrentDirectory(), "../../../../identityfirestore.json"))
.Build();
var services = new ServiceCollection();
services.Configure <OAuthServiceAccountKey>(options =>
{
configuration.GetSection("FirestoreAuthTokenOptions").Bind(options);
})
.AddScoped(provider =>
{
var authOptions = provider.GetRequiredService <IOptions <OAuthServiceAccountKey> >();
var json = JsonConvert.SerializeObject(authOptions.Value);
var credentials = GoogleCredential.FromJson(json)
.CreateScoped("https://www.googleapis.com/auth/datastore");
var channel = new Grpc.Core.Channel(
FirestoreClient.DefaultEndpoint.ToString(),
credentials.ToChannelCredentials());
var client = FirestoreClient.Create(channel);
return(FirestoreDb.Create(authOptions.Value.project_id, client: client));
});
return(services.BuildServiceProvider().GetRequiredService <FirestoreDb>());
}
static object SyncRecognizeWithCredentials(string filePath, string credentialsFilePath)
{
GoogleCredential googleCredential;
using (Stream m = new FileStream(credentialsFilePath, FileMode.Open))
googleCredential = GoogleCredential.FromStream(m);
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.Host,
googleCredential.ToChannelCredentials());
var speech = SpeechClient.Create(channel);
var response = speech.Recognize(new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en",
}, RecognitionAudio.FromFile(filePath));
foreach (var result in response.Results)
{
foreach (var alternative in result.Alternatives)
{
Console.WriteLine(alternative.Transcript);
}
}
return(0);
}
public static string DetectIntent(string text)
{
var query = new QueryInput
{
Text = new TextInput
{
Text = text,
LanguageCode = "ru"
}
};
var sessionId = Guid.NewGuid().ToString();
var agent = "smalltalkbot-atvxnh";
var creds = IntentDetector.Creds;
var channel = new Grpc.Core.Channel(SessionsClient.DefaultEndpoint.Host,
creds.ToChannelCredentials());
var client = SessionsClient.Create(channel);
var dialogFlow = client.DetectIntent(
new SessionName(agent, sessionId),
query
);
channel.ShutdownAsync();
return(dialogFlow.QueryResult.FulfillmentText);
}
public static LongRunningRecognizeResponse stt_google(string mediaShortName, string languageId)
{
try
{
GoogleCredential googleCredential;
var req = WebRequest.Create(WebConfiguration.googlecredentialsfile);
using (Stream m = req.GetResponse().GetResponseStream())
googleCredential = GoogleCredential.FromStream(m);
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.Host, googleCredential.ToChannelCredentials());
var speech = SpeechClient.Create(channel);
Console.WriteLine("***GoogleRecognizeSST SpeechClient init ");
//Init Google Object
string bucketName = WebConfiguration.bucketName;
var longOperation = speech.LongRunningRecognize(new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 48000,
LanguageCode = String.IsNullOrEmpty(languageId) ? System.Configuration.ConfigurationManager.AppSettings["LanguageCode"] : languageId,
}, RecognitionAudio.FromStorageUri("gs://" + bucketName + "/" + mediaShortName));
Console.WriteLine("***GoogleRecognizeSST processing");
longOperation = longOperation.PollUntilCompleted();
return(longOperation.Result);
}
catch (Exception ex)
{
SharedHelper.GetFullException(ex);
return(null);
}
}
// private static readonly HttpClient SingleClient = new HttpClient();
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override void Execute(NativeActivityContext context)
{
var text = Text.Get(context);
string filePath = File_Path.Get(context);
string apiKey = API_KEY.Get(context);
if (filePath != null)
{
var credential = GoogleCredential.FromFile(filePath).CreateScoped(LanguageServiceClient.DefaultScopes);
var channel = new Grpc.Core.Channel(LanguageServiceClient.DefaultEndpoint.ToString(), credential.ToChannelCredentials());
var client = LanguageServiceClient.Create(channel);
var response = client.AnalyzeSentiment(new Document()
{
Content = text,
Type = Document.Types.Type.PlainText
});
var sentiment = response.DocumentSentiment;
// Console.WriteLine($"Score: {sentiment.Score}");
// Console.WriteLine($"Magnitude: {sentiment.Magnitude}");
SentimentScore.Set(context, sentiment.Score);
SentimentMagnitude.Set(context, sentiment.Magnitude);
}
else if (apiKey != null)
{
// @TODO Authentication using API Key [Work in progress]
var nlp_base_url = "https://language.googleapis.com/v1beta2/";
var operation = "documents:analyzeSentiment";
var key = "?key=" + API_KEY.Get(context);
var request_url = nlp_base_url + operation + key;
object content = new
{
document = new
{
content = text,
type = "PLAIN_TEXT"
},
encodingType = "UTF8"
};
Task <(HttpResponseMessage, String)> response_message = Task.Run(() => PostBasicAsync(request_url, content));
response_message.Wait();
(HttpResponseMessage result_json, String stringContent) = response_message.Result;
// string request_content = stringContent.ReadAsStringAsync().Result;
// ContentBody.Set(context, "\nStringContent - \n" + stringContent);
GoogleNLPResponseMessage.Set(context, result_json);
}
}
/// <summary>
/// Returns a poll response for the given operationName corresponding to a long-running recognize operation.
/// </summary>
/// <param name="operationName"></param>
/// <returns></returns>
private Google.LongRunning.Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> GetLongRunningRecognizePollResponse(string operationName)
{
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.Host, GetCredential().ToChannelCredentials());
var speechClient = SpeechClient.Create(channel);
WriteDebugEntry("Initiating polling of long-running recognize operation " + operationName + ".");
return(speechClient.PollOnceLongRunningRecognize(operationName));
}
ImageAnnotatorClient GetClient()
{
var credential = GoogleCredential.FromFile(@"C:\Users\David Appel\Documents\creds\TextProcessor.json").CreateScoped(LanguageServiceClient.DefaultScopes);
var channel = new Grpc.Core.Channel(ImageAnnotatorClient.DefaultEndpoint.ToString(), credential.ToChannelCredentials());
// Instantiates a client
return(ImageAnnotatorClient.Create(channel));
}
private static SpeechClient SpeechProperty()
{
var credential = GoogleCredential.FromFile(CredentialPath);
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.Host, credential.ToChannelCredentials());
var speech = SpeechClient.Create(channel);
return(speech);
}
public static float GetImageData(string Term, string ImagePath)
{
string directory = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory);
string jsonPath = directory + "\\Utility\\my-project-90986-379273cc3cd3.json";
// credential = GoogleCredential.FromFile(jsonPath);
var credential = GoogleCredential.FromFile(jsonPath)
.CreateScoped(ImageAnnotatorClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
ImageAnnotatorClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = ImageAnnotatorClient.Create(channel
);
var image = Image.FromFile(ImagePath);
var response = client.DetectLocalizedObjects(image);
foreach (var annotation in response)
{
if (annotation.Name != null)
{
if (annotation.Name.ToLower() == Term.ToLower())
{
return(annotation.Score);
}
}
}
var response2 = client.DetectLabels(image);
foreach (var annotation in response2)
{
if (annotation.Description != null)
{
if (annotation.Description.ToLower() == Term.ToLower())
{
return(annotation.Score);
}
}
}
var response3 = client.DetectWebInformation(image);
foreach (var annotation in response3.WebEntities)
{
if (annotation.Description != null)
{
if (annotation.Description.ToLower() == Term.ToLower())
{
return(annotation.Score);
}
}
}
return(0.0f);
}
public int DetectIntentFromTexts(
string sessionId,
string text,
string languageCode = "en-US")
{
string projectId = "INSERT_PROJECT_ID_HERE";
var creds = GoogleCredential.FromJson("INSERT_KEY_HERE");
var channel = new Grpc.Core.Channel(SessionsClient.DefaultEndpoint.Host, creds.ToChannelCredentials());
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var client = SessionsClient.Create(channel);
var response = client.DetectIntent(
session: new SessionName(projectId, sessionId),
queryInput: new QueryInput()
{
Text = new TextInput()
{
Text = text,
LanguageCode = languageCode
}
}
);
var queryResult = response.QueryResult;
var detectedIntent = queryResult.Intent.DisplayName;
var state = graph.GetStateAsync(sessionId);
if (state == null)
{
graph.SendHelloAsync(sessionId).Wait();
}
else if (state.CurrentContext == Startup.BotContext.Quiz.ToString())
{
QuizContextProcessing(sessionId, detectedIntent, queryResult, state);
}
//else if (state.CurrentContext == Startup.BotContext.Feedback.ToString())
//{
// FeedbackProcessing(sessionId, detectedIntent, queryResult);
//}
else if (state.CurrentContext == Startup.BotContext.Email.ToString())
{
EmailProcessing(sessionId, detectedIntent, queryResult);
}
else if (state.CurrentContext == Startup.BotContext.Ineligible.ToString())
{
IneligibleContextProcessing(sessionId, detectedIntent, queryResult);
}
else if (state.CurrentContext == Startup.BotContext.Welcome.ToString())
{
WelcomeContextProcessing(sessionId, detectedIntent, queryResult);
}
return(0);
}
private void ButtonConnect_Click(object sender, EventArgs e)
{
if (client == null)
{
// Setup a new connection
this.buttonConnect.Text = "Disconnect"; // If they click on it again, it will disconnect.
// Prevent the user from changing the connection parameters while connected.
this.textBoxURL.Enabled = false;
this.checkBoxSecureConnection.Enabled = false;
this.buttonTranscribe.Enabled = true;
// Setup gRPC stuff
var url = textBoxURL.Text;
var creds = Grpc.Core.ChannelCredentials.Insecure;
if (this.checkBoxSecureConnection.Checked)
{
creds = new Grpc.Core.SslCredentials();
}
Grpc.Core.Channel channel = new Grpc.Core.Channel(url, creds);
client = new CobaltSpeech.Cubic.Cubic.CubicClient(channel);
// Fetch the Models
var listModelsRequest = new CobaltSpeech.Cubic.ListModelsRequest();
var models = client.ListModels(listModelsRequest);
cubicModels = new List <CobaltSpeech.Cubic.Model> {
};
this.modelPicker.Enabled = true;
foreach (var m in models.Models)
{
this.modelPicker.Items.Add(m.Name);
cubicModels.Add(m);
}
// Fetch the Version
var versions = client.Version(new Google.Protobuf.WellKnownTypes.Empty());
this.labelVersion.Text = String.Format("Versions: CubicSvr {0}, Cubic {1}", versions.Server, versions.Cubic);
}
else
{
// We want to disconnect
this.buttonConnect.Text = "Connect";
this.textBoxURL.Enabled = true;
this.checkBoxSecureConnection.Enabled = true;
this.buttonTranscribe.Enabled = false; // Must be connected before clicking Transcribe
// Clear out the model combo box
this.modelPicker.Items.Clear();
this.modelPicker.Enabled = false; // Must be connected before a model can be selected
// Close down the session
cubicModels = null;
client = null;
}
}
public object AuthExplicitComputeEngine(string projectId)
{
var credential = GoogleCredential.FromComputeCredential();
var channel = new Grpc.Core.Channel(
LanguageServiceClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = LanguageServiceClient.Create(channel);
AnalyzeSentiment(client);
return(0);
}
// Other APIs, like Language, accept a channel in their Create()
// method.
public static SpeechClient AuthExplicitComputeEngine(string projectId)
{
var credential = GoogleCredential.FromComputeCredential();
var channel = new Grpc.Core.Channel(
SpeechClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = SpeechClient.Create();
return(client);
}
static public void conection(string json1)
{
var credential = GoogleCredential.FromJson(json1).CreateScoped(FirestoreClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
FirestoreClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
client = FirestoreClient.Create(channel);
}
public override RemoteConnection ConnectToServer(RemoteServerInfo serverInfo)
{
try
{
var channel = new Grpc.Core.Channel(
serverInfo.ServerIp,
serverInfo.ServerPort,
Grpc.Core.ChannelCredentials.Insecure,
/* keep config and naming using diff channel */
new List <Grpc.Core.ChannelOption> {
new Grpc.Core.ChannelOption(GetName(), 1)
});
// after nacos alpha2 server check response was changed!!
var response = ServerCheck(channel);
if (response == null || response is not ServerCheckResponse scResp)
{
ShuntDownChannel(channel);
return(null);
}
var streamClient = new Nacos.BiRequestStream.BiRequestStreamClient(channel);
var requestClient = new Nacos.Request.RequestClient(channel);
GrpcConnection grpcConn = new GrpcConnection(serverInfo);
grpcConn.SetConnectionId(scResp.ConnectionId);
var streamCall = BindRequestStream(streamClient, grpcConn);
// stream observer to send response to server
grpcConn.SetBiRequestStreamClient(streamCall);
grpcConn.SetRequestClient(requestClient);
grpcConn.SetChannel(channel);
// after nacos alpha2 setup request was changed!!
ConnectionSetupRequest conSetupRequest = new ConnectionSetupRequest
{
ClientVersion = Constants.CLIENT_VERSION,
Labels = labels,
Abilities = clientAbilities,
ClientIp = Utils.NetUtils.LocalIP(),
Tenant = GetTenant()
};
grpcConn.SendRequest(conSetupRequest, BuildMeta(conSetupRequest.GetRemoteType()));
return(grpcConn);
}
catch (Exception ex)
{
logger?.LogError(ex, "[{0}]Fail to connect to server!", this.GetName());
return(null);
}
}
public async Task <ModerationResponse> AnalyzeImage(byte[] imageBytes)
{
var channel = new Grpc.Core.Channel(ImageAnnotatorClient.DefaultEndpoint.Host, Credentials.ToChannelCredentials());
try
{
var client = ImageAnnotatorClient.Create(channel);
var image = Image.FromBytes(imageBytes);
var response = await client.DetectSafeSearchAsync(image);
var moderationResponse = new ModerationResponse();
moderationResponse.ModerationScores = new[] {
new ModerationScore()
{
Category = $"Adult", Score = ConvertLikelyhood(response.Adult)
},
new ModerationScore()
{
Category = $"Medical", Score = ConvertLikelyhood(response.Medical)
},
new ModerationScore()
{
Category = $"Spoof", Score = ConvertLikelyhood(response.Spoof)
},
new ModerationScore()
{
Category = $"Violent", Score = ConvertLikelyhood(response.Violence)
}
};
moderationResponse.Pass = !moderationResponse.ModerationScores.Any(s => s.Score > .40F);
return(moderationResponse);
}
catch (Exception ex)
{
return(new ModerationResponse()
{
Pass = false,
ModerationScores = new[] { new ModerationScore()
{
Category = $"ServerError:{ex.Message}", Score = 100
} }
});
}
finally
{
await channel.ShutdownAsync();
}
}
public string Query(string Question)
{
if (channel != null)
{
if(channel.State == Grpc.Core.ChannelState.Shutdown ||
channel.State == Grpc.Core.ChannelState.TransientFailure)
{
channel = null;
}
}
if (channel == null) Init();
var query = new QueryInput
{
Text = new TextInput
{
Text = Question,
LanguageCode = "en-us"
}
};
DetectIntentResponse dialogFlow =null;
try
{
dialogFlow = client.DetectIntent(
new SessionName(AgentID, sessionId),
query
);
}
catch (Exception ex)
{
NetworkError.Message = ex.Message;
NetworkError.StackTrace = ex.ToString();
return "I am unable to access the internet network. Can you please make sure your network is online?";
}
dialogFlowString = dialogFlow.ToString();
Response.CreateResponseObject(dialogFlowString);
QueryResult = dialogFlow.QueryResult.ToString();
FulfillmentText = dialogFlow.QueryResult.FulfillmentText;
if (FulfillmentText.Trim() == "") FulfillmentText = "I am sorry, I do not have a comment at this moment. Can you try again?";
if (IsChannelKeepAlive == false)
{
channel.ShutdownAsync();
}
return FulfillmentText;
}
public object AuthExplicit(string projectId, string jsonPath)
{
var credential = GoogleCredential.FromFile(jsonPath)
.CreateScoped(LanguageServiceClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
LanguageServiceClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = LanguageServiceClient.Create(channel);
AnalyzeSentiment(client);
return(0);
}
public static ImageAnnotatorClient GetClient()
{
var path = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, System.AppDomain.CurrentDomain.RelativeSearchPath ?? "");
var credential = GoogleCredential.FromFile($"{path}\\token.json")
.CreateScoped(ImageAnnotatorClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
ImageAnnotatorClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var imageAnnotatorClient = ImageAnnotatorClient.Create(channel);
return(imageAnnotatorClient);
}
