We've tested more than 100 anti-malware apps to help you find the top malware protection and removal software for all your devices. When the IBM PC was new, I served as the president of the San ...

The Best Malware Removal and Protection Software for 2023

The government on Thursday sought to allay the concerns over the decision to put imports of certain computer hardware in restricted category, with mandatory licensing, by coming up with a liberal authorisation process.

No Caps Or Country-Specific Curbs Under New Laptop Import Policy

The Indian government has announced that it will allow restriction-free imports of laptops and tablets, and has introduced a new "import management system" to monitor shipments without affecting the supply.

India allows restriction-free laptop imports

The government is likely to ask for international certification from IT hardware importers to establish a trusted supply chain for India.

IT Hardware Importers May Need Int’l Certification For India

If that's the case, grab your old music player because you can transfer the music from your iPod to your computer. To do so, you just need to consider your iPod as an external drive from which you ...

How to Transfer Music From an Old iPod to Your Computer or iPhone

After a surprising announcement of license requirements for imported computers, India rolled back the policy, saying there would be no import restrictions while insisting a management system be ...

India rolls back license restriction on imported notebooks

PLUS: TSMC chips away at export restrictions; Singapore's COVID model challenged; Japan's banking and ID systems wobble India's government has stepped away from its plan to require manufacturers of PCs,

India drops plan to place PCs on restricted import list

The warning was issued by GitHub after the software development platform recently disclosed the existence of a memory corruption flaw in the libcue library which parses cue sheets. It’s being ...

This software relic from the CD era could put your entire PC at risk

Explaining further, Director General of Foreign Trade (DGFT) Santosh Kumar Sarangi said there will be an import management system, which will come into place from November 1. The work is in progress and hopefully it will be in place before October 30 ...

No restriction on laptop imports; we are only monitoring: Commerce Secretary

Import.io

importio

Mastering Multi-Cloud and Edge Data Synchronization: A Retail Use Case with KubeMQ’s Java SDK

Effortlessly Launch LangChain APIs with LangServe and MinIO Integration

অনায়াসে LangServe এবং MinIO ইন্টিগ্রেশন সহ LangChain API চালু করুন

Müheloses Starten von LangChain-APIs mit LangServe- und MinIO-Integration

Lance las API de LangChain sin esfuerzo con la integración de LangServe y MinIO

Lancez sans effort les API LangChain avec l'intégration LangServe et MinIO

LangServe और MinIO एकीकरण के साथ LangChain API को आसानी से लॉन्च करें

LangServe と MinIO の統合により LangChain API を簡単に起動

LangServe 및 MinIO 통합을 통해 LangChain API를 손쉽게 실행

Inicie APIs LangChain sem esforço com integração LangServe e MinIO

Легко запускайте API-интерфейсы LangChain с интеграцией LangServe и MinIO.

LangServe ve MinIO Entegrasyonu ile LangChain API'lerini Zahmetsizce Başlatın

Dễ dàng khởi chạy API LangChain với tích hợp LangServe và MinIO

通过 LangServe 和 MinIO 集成轻松启动 LangChain API

Leveraging MinIO and Apache Tika for Automated Text Extraction and Analysis

স্বয়ংক্রিয় পাঠ্য নিষ্কাশন এবং বিশ্লেষণের জন্য MinIO এবং Apache Tika ব্যবহার করা

Nutzung von MinIO und Apache Tika zur automatischen Textextraktion und -analyse

Aprovechando MinIO y Apache Tika para la extracción y el análisis de texto automatizados

Tirer parti de MinIO et Apache Tika pour l’extraction et l’analyse automatisées de texte

स्वचालित पाठ निष्कर्षण और विश्लेषण के लिए मिनियो और अपाचे टिका का लाभ उठाना

MinIO と Apache Tika を活用した自動テキスト抽出と分析

자동화된 텍스트 추출 및 분석을 위해 MinIO 및 Apache Tika 활용

Aproveitando MinIO e Apache Tika para extração e análise automatizada de texto

Использование MinIO и Apache Tika для автоматического извлечения и анализа текста

Otomatik Metin Çıkarma ve Analizi için MinIO ve Apache Tika'dan Yararlanma

Tận dụng MinIO và Apache Tika để trích xuất và phân tích văn bản tự động

利用 MinIO 和 Apache Tika 进行自动文本提取和分析

Hey everyone! I’m Nataraj, and just like you, I’ve been fascinated with the recent progress of artificial intelligence. Realizing that I needed to stay abreast with all the developments happening, I decided to embark on a personal journey of learning, thus 100 days of AI was born! With this series, I will be learning about LLMs and share ideas, experiments, opinions, trends & learnings through my blog posts. You can follow along the journey on HackerNoon here or my personal website here. In today’s article, we’ll be looking to build a Semantic Kernel with the help of GPT-4. If you are reading the 100 Days of AI series I am writing a common theme that you will notice is most of the posts have some kind of an experiment or a demo. At the end of posts I also list ideas that are possible with the technologies I explored. So the obvious next question is, is there a way to easily wrap these experiments into demo-able products and share them with people and get feedback? In this post we will explore how to easily convert an AI experiment into a demo that can be and get feedback. Let’s say you want to create an AI app that takes in text and returns a summary. And you want to share it with people and get feedback. If you have to create a web app for this app, you have to code the UI make sure you find a hosting solution and figure out what the entire stack is going to be. Of course there are started webapp stacks that will allow to do it more faster but you don’t need all that complexity for your use case. Instead we will use Gradio which create a web app like interface with out writing any code for this app. What is Gradio? Gradio is a python library that allows you to easily create demos of your AI apps and share it with an audience in the form of a web app. To understand how to easily demo a gen AI experiment with Gradio, we will build a summarization web app where you can give the app a long text and the app will output the summary of that long text. Step 1: Setup Along with Gradio, we will use hugging face app so to follow along make sure you keep your hugging face api key handy. To get started lets load up the API key from .env file and add required python modules. import os
import io
from IPython.display import Image, display, HTML
#from PIL import Image
import base64 
import openai

env_path = '../.env'
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv(env_path)) # read local .env file

hf_api_key = os.environ['HF_API_KEY'] Step 2: Define Summarization Function The core logic of what we want to achieve is to send a long text to a model and get a summary of the text. We will define a function that takes in the long text as an input and calls a model on hugging face called distilbart. Here is the function to do this. def get_completion(inputs, parameters=None, ENDPOINT_URL=os.environ['HF_API_SUMMARY_BASE']): 
    headers = {
      "Authorization": f"Bearer {hf_api_key}",
      "Content-Type": "application/json"
    }
    data = { "inputs": inputs }
    if parameters is not None:
        data.update({"parameters": parameters})
    response = requests.request("POST",
                                ENDPOINT_URL, headers=headers,
                                data=json.dumps(data)
                               )
    return json.loads(response.content.decode("utf-8")) Step 3: Use Gradio to Demo Summarization App The main way to interact with Gradio is through interface function. We need to pass a function and its corresponding inputs and outputs. Note that we defined a new function called summarize for this purpose. This function takes an input, which will be the long text which is to be summarized and the function will call the get_completion function from step 2 to get the summary of the input text and return that as the output. In the final line we are asking gradio to launch the demo of this app. By providing share=True we are telling gradio to create a public link that can be shared to others and also giving the server_port on which the local webhost should run on. In the below code we also customize the title, description and labels of input and output fields which you will notice in the out put. import gradio as gr
def summarize(input):
    output = get_completion(input)
    return output[0]['summary_text']
    
gr.close_all()
demo = gr.Interface(fn=summarize, 
                    inputs=[gr.Textbox(label="Text to summarize", lines=6)],
                    outputs=[gr.Textbox(label="Result", lines=3)],
                    title="Text summarization with distilbart-cnn",
                    description="Summarize any text using the `shleifer/distilbart-cnn-12-6` model under the hood!"
                   )
demo.launch(share=True, server_port=int(os.environ['PORT1'])) Once you run this, here is what the output now looks like in your browser at http://127.0.0.1:<your port number>. It is that easy to demo a project with Gradio. The beauty here is you as a developer didn’t have to come up with UI stack and go through with the complexity of learning that stack and taking it to production. Gradio does it for you. Gradio offers different input and output types using which you can create more complex and interesting demos that can be easily shared. We will explore more demos with Gradio and other tools in the coming posts. That’s it for Day 12 of 100 Days of AI. I write a newsletter called Above Average where I talk about the second order insights behind everything that is happening in big tech. If you are in tech and don’t want to be average, subscribe to it. Follow me on Twitter, LinkedIn or HackerNoon for latest updates on 100 days of AI. If you are in tech you might be interested in joining my community of tech professionals here. Hey everyone! I’m Nataraj, and just like you, I’ve been fascinated with the recent progress of artificial intelligence. Realizing that I needed to stay abreast with all the developments happening, I decided to embark on a personal journey of learning, thus 100 days of AI was born! With this series, I will be learning about LLMs and share ideas, experiments, opinions, trends & learnings through my blog posts. You can follow along the journey on HackerNoon here or my personal website here. In today’s article, we’ll be looking to build a Semantic Kernel with the help of GPT-4. Hey everyone! I’m Nataraj, and just like you, I’ve been fascinated with the recent progress of artificial intelligence. Realizing that I needed to stay abreast with all the developments happening, I decided to embark on a personal journey of learning, thus 100 days of AI was born! With this series, I will be learning about LLMs and share ideas, experiments, opinions, trends & learnings through my blog posts. You can follow along the journey on HackerNoon here or my personal website here. In today’s article, we’ll be looking to build a Semantic Kernel with the help of GPT-4. Hey everyone! I’m Nataraj, and just like you, I’ve been fascinated with the recent progress of artificial intelligence. Realizing that I needed to stay abreast with all the developments happening, I decided to embark on a personal journey of learning, thus 100 days of AI was born! With this series, I will be learning about LLMs and share ideas, experiments, opinions, trends & learnings through my blog posts. You can follow along the journey on HackerNoon here or my personal website here . In today’s article, we’ll be looking to build a Semantic Kernel with the help of GPT-4. I’m Nataraj , I’m Nataraj 100 days of AI 100 days of AI here here here here If you are reading the 100 Days of AI series I am writing a common theme that you will notice is most of the posts have some kind of an experiment or a demo. At the end of posts I also list ideas that are possible with the technologies I explored. So the obvious next question is, is there a way to easily wrap these experiments into demo-able products and share them with people and get feedback? In this post we will explore how to easily convert an AI experiment into a demo that can be and get feedback. Let’s say you want to create an AI app that takes in text and returns a summary. And you want to share it with people and get feedback. If you have to create a web app for this app, you have to code the UI make sure you find a hosting solution and figure out what the entire stack is going to be. Of course there are started webapp stacks that will allow to do it more faster but you don’t need all that complexity for your use case. Instead we will use Gradio which create a web app like interface with out writing any code for this app. What is Gradio? Gradio is a python library that allows you to easily create demos of your AI apps and share it with an audience in the form of a web app. To understand how to easily demo a gen AI experiment with Gradio, we will build a summarization web app where you can give the app a long text and the app will output the summary of that long text. Step 1: Setup Step 1: Setup Along with Gradio, we will use hugging face app so to follow along make sure you keep your hugging face api key handy. To get started lets load up the API key from .env file and add required python modules. import os
import io
from IPython.display import Image, display, HTML
#from PIL import Image
import base64 
import openai

env_path = '../.env'
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv(env_path)) # read local .env file

hf_api_key = os.environ['HF_API_KEY'] import os
import io
from IPython.display import Image, display, HTML
#from PIL import Image
import base64 
import openai

env_path = '../.env'
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv(env_path)) # read local .env file

hf_api_key = os.environ['HF_API_KEY'] Step 2: Define Summarization Function The core logic of what we want to achieve is to send a long text to a model and get a summary of the text. We will define a function that takes in the long text as an input and calls a model on hugging face called distilbart . Here is the function to do this. distilbart def get_completion(inputs, parameters=None, ENDPOINT_URL=os.environ['HF_API_SUMMARY_BASE']): 
    headers = {
      "Authorization": f"Bearer {hf_api_key}",
      "Content-Type": "application/json"
    }
    data = { "inputs": inputs }
    if parameters is not None:
        data.update({"parameters": parameters})
    response = requests.request("POST",
                                ENDPOINT_URL, headers=headers,
                                data=json.dumps(data)
                               )
    return json.loads(response.content.decode("utf-8")) def get_completion(inputs, parameters=None, ENDPOINT_URL=os.environ['HF_API_SUMMARY_BASE']): 
    headers = {
      "Authorization": f"Bearer {hf_api_key}",
      "Content-Type": "application/json"
    }
    data = { "inputs": inputs }
    if parameters is not None:
        data.update({"parameters": parameters})
    response = requests.request("POST",
                                ENDPOINT_URL, headers=headers,
                                data=json.dumps(data)
                               )
    return json.loads(response.content.decode("utf-8")) Step 3: Use Gradio to Demo Summarization App The main way to interact with Gradio is through interface function. We need to pass a function and its corresponding inputs and outputs. Note that we defined a new function called summarize for this purpose. This function takes an input, which will be the long text which is to be summarized and the function will call the get_completion function from step 2 to get the summary of the input text and return that as the output . In the final line we are asking gradio to launch the demo of this app. By providing share=True we are telling gradio to create a public link that can be shared to others and also giving the server_port on which the local webhost should run on. In the below code we also customize the title, description and labels of input and output fields which you will notice in the out put. interface summarize get_completion output share=True import gradio as gr
def summarize(input):
    output = get_completion(input)
    return output[0]['summary_text']
    
gr.close_all()
demo = gr.Interface(fn=summarize, 
                    inputs=[gr.Textbox(label="Text to summarize", lines=6)],
                    outputs=[gr.Textbox(label="Result", lines=3)],
                    title="Text summarization with distilbart-cnn",
                    description="Summarize any text using the `shleifer/distilbart-cnn-12-6` model under the hood!"
                   )
demo.launch(share=True, server_port=int(os.environ['PORT1'])) import gradio as gr
def summarize(input):
    output = get_completion(input)
    return output[0]['summary_text']
    
gr.close_all()
demo = gr.Interface(fn=summarize, 
                    inputs=[gr.Textbox(label="Text to summarize", lines=6)],
                    outputs=[gr.Textbox(label="Result", lines=3)],
                    title="Text summarization with distilbart-cnn",
                    description="Summarize any text using the `shleifer/distilbart-cnn-12-6` model under the hood!"
                   )
demo.launch(share=True, server_port=int(os.environ['PORT1'])) Once you run this, here is what the output now looks like in your browser at http://127.0.0.1:<your port number>. It is that easy to demo a project with Gradio. The beauty here is you as a developer didn’t have to come up with UI stack and go through with the complexity of learning that stack and taking it to production. Gradio does it for you. Gradio offers different input and output types using which you can create more complex and interesting demos that can be easily shared. We will explore more demos with Gradio and other tools in the coming posts. That’s it for Day 12 of 100 Days of AI. That’s it for Day 12 of 100 Days of AI. That’s it for Day 12 of 100 Days of AI. I write a newsletter called Above Average where I talk about the second order insights behind everything that is happening in big tech. If you are in tech and don’t want to be average, subscribe to it . I write a newsletter called Above Average where I talk about the second order insights behind everything that is happening in big tech. If you are in tech and don’t want to be average, subscribe to it subscribe to it Follow me on Twitter , LinkedIn or HackerNoon for latest updates on 100 days of AI. If you are in tech you might be interested in joining my community of tech professionals here . Twitter Twitter LinkedIn LinkedIn HackerNoon HackerNoon here here

100 Days of AI, Day 12: How to Quickly Demo Your Gen AI Experiments to Get Feedback

এআই-এর 100 দিন, 12 দিন: প্রতিক্রিয়া পেতে আপনার জেনারেল এআই পরীক্ষাগুলি কীভাবে দ্রুত ডেমো করবেন

100 Tage KI, Tag 12: So demonstrieren Sie schnell Ihre Gen-KI-Experimente, um Feedback zu erhalten

100 días de IA, día 12: Cómo realizar una demostración rápida de sus experimentos de IA de generación para obtener comentarios

100 jours d'IA, jour 12 : comment faire une démonstration rapide de vos expériences Gen AI pour obtenir des commentaires

एआई के 100 दिन, दिन 12: फीडबैक प्राप्त करने के लिए अपने जनरल एआई प्रयोगों का त्वरित प्रदर्शन कैसे करें

100 日間の AI、12 日目: Gen AI 実験をすばやくデモしてフィードバックを得る方法

AI 100일, 12일차: Gen AI 실험을 빠르게 시연하여 피드백을 받는 방법

100 dias de IA, dia 12: como demonstrar rapidamente seus experimentos de Gen AI para obter feedback

100 дней искусственного интеллекта, день 12: как быстро продемонстрировать свои эксперименты с искусственным интеллектом, чтобы получить обратную связь

100 Gün Yapay Zeka, 12. Gün: Geri Bildirim Almak İçin Nesil Yapay Zeka Deneylerinizi Hızlı Bir Şekilde Nasıl Tanıtabilirsiniz?

100 ngày AI, Ngày 12: Cách demo nhanh các thử nghiệm AI thế hệ của bạn để nhận phản hồi

人工智能 100 天，第 12 天：如何快速演示您的新一代人工智能实验以获得反馈

In the , we figured out how to implement  server-side interceptors. In this article, we try to figure out how to log GRPC requests on the client side. We must implement three interfaces ClientInterceptor, ClientCall, and ClientCall.Listener. previous article There are default implementations such as SimpleForwardingClientCall and SimpleForwardingClientCallListener in which all methods are implemented. If we look at their implementation, we can see that they invoke a next implementation ClientCall or ClientCall.Listener. The Implementation Our implementation will be straightforward; we will store requests and responses in Queues, and then put this data to MDC. First, let’s implement ClientCall.Listener. import com.google.protobuf.GeneratedMessageV3
import com.google.protobuf.util.JsonFormat
import io.grpc.ClientCall
import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener
import io.grpc.Metadata
import io.grpc.Status
import org.slf4j.LoggerFactory
import org.slf4j.MDC
import java.util.Queue

class LoggingClientCallListener<ReqT, ResT>(
    delegate: ClientCall.Listener<ResT>,
    private val requestQueue: Queue<ReqT>,
    private val responseQueue: Queue<ResT>
) : SimpleForwardingClientCallListener<ResT>(delegate) {

    override fun onMessage(message: ResT) {
        responseQueue.offer(message)
        super.onMessage(message)
    }

    override fun onClose(status: Status, trailers: Metadata) {
        val request = requestQueue
            .filterIsInstance<GeneratedMessageV3>()
            .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = PROTOBUF_TO_JSON_PRINTER::print)

        val response = responseQueue
            .filterIsInstance<GeneratedMessageV3>()
            .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = PROTOBUF_TO_JSON_PRINTER::print)

        if (status.isOk) {
            MDC.put("request", request)
            MDC.put("response", response)
            logger.info("The request was processed successfully")
            MDC.clear()
        } else if (UNSUCCESSFUL_STATUS_CODES.contains(status.code)) {
            MDC.put("request", request)
            logger.error("An error occurred while processing the request", status.asRuntimeException())
            MDC.clear()
        }

        super.onClose(status, trailers)
    }

    companion object {
        private val logger = LoggerFactory.getLogger(LoggingServerCallListener::class.java)
        private val PROTOBUF_TO_JSON_PRINTER = JsonFormat.printer()
        private val UNSUCCESSFUL_STATUS_CODES = listOf(
            Status.INVALID_ARGUMENT.code,
            Status.INTERNAL.code,
            Status.NOT_FOUND.code
        )
    }
} We have overridden the two methods. First, we have overridden the onMessage method. The method will be invoked before the client will receive data. The method can be invoked from zero to n times if the method result is defined as Stream. Second, we have overridden the onClose method. The method will be called before the client closes the connection, and no data will be retrieved after that. After that, we must implement the interface ClientCall. import io.grpc.ClientCall
import io.grpc.ForwardingClientCall.SimpleForwardingClientCall
import io.grpc.Metadata
import java.util.*

class LoggingClientCall<ReqT, RespT>(
    delegate: ClientCall<ReqT, RespT>,
    private val requestQueue: Queue<ReqT>,
    private val responseQueue: Queue<RespT>
) : SimpleForwardingClientCall<ReqT, RespT>(delegate) {

    override fun sendMessage(message: ReqT) {
        requestQueue.offer(message)
        super.sendMessage(message)
    }

    override fun start(responseListener: Listener<RespT>, headers: Metadata) {
        super.start(LoggingClientCallListener(responseListener, requestQueue, responseQueue), headers)
    }
} We have overridden two methods also. First, we have overridden the sendMessage method. This method will be invoked before a message will be sent to a service. We push our message to the queue. In the next method, we create our implementation of our LoggingClientCallListener. This method will be invoked before all methods. Next, we must implement our client interceptor and register this interceptor in the stub. import io.grpc.*
import java.util.concurrent.LinkedBlockingDeque

class LoggingClientInterceptor : ClientInterceptor {
    override fun <ReqT : Any, RespT : Any> interceptCall(
        method: MethodDescriptor<ReqT, RespT>,
        callOptions: CallOptions,
        next: Channel
    ): ClientCall<ReqT, RespT> {
        return LoggingClientCall(next.newCall(method, callOptions), LinkedBlockingDeque(), LinkedBlockingDeque())
    }
} fun main(args: Array<String>) {
	val client = OurServiceGrpc
		.newBlockingStub(ManagedChannelBuilder.forAddress("localhost", 8080).build())
		.withInterceptors(LoggingClientInterceptor())
} I hope I managed to show you how to use server and client interceptors in GRPC.

How to Implement Client-Side Interceptors for Logging GRPC Requests

Once, I had a requirement to implement server-side logging for GRPC requests. GRPC has an interceptor mechanism that can be used for logging, GRPC request verification, authentication, etc. To intercept requests on the server side, it is necessary to implement ServerInterceptor. And inherit two abstract classes, ServerCall and ServerCall.Listener. First, let’s make our implementation of ServerCall.Listener. There is ForwardingServerCallListener that gives calls to the next listener in the chain. We will extend this class and override the method onMessage. We will use the ConcurrentLinkedQueue for storing received requests. This method might be invoked more than one time if using client-side streaming. Also, there are the onComplete and onCancel methods that will be invoked after completing the GRPC request or after the client’s cancelation. Our implementation uses the queue for storing sent requests. class LoggingServerCallListener<ReqT>(
    private val delegate: ServerCall.Listener<ReqT>,
    private val input: ConcurrentLinkedQueue<ReqT>
) : ForwardingServerCallListener<ReqT>() {

    override fun delegate(): ServerCall.Listener<ReqT> {
        return delegate
    }

    override fun onMessage(message: ReqT) {
        super.onMessage(message)
        input.offer(message)
    }
} Next, we need to implement the ServerCall class. There is the implementation SimpleForwardingServerCall that works as ForwardingServerCallListener for ServerCall.Listener. We will use the same instance of ConcurrentLinkedQueue for getting received requests. Also, we will use another instance of the queue for storing sent responses. We will implement the sendMessage method that invokes before a response is sent to a client. This method can be invoked more than once if the result is server-side streaming. We will also override the close method, which will be called after all data has been sent to the client or an error occurs. The method ensures that there will be no further calls to onMessage or sendMessage. import com.google.protobuf.GeneratedMessageV3
import com.google.protobuf.util.JsonFormat
import io.grpc.ForwardingServerCall.SimpleForwardingServerCall
import io.grpc.Metadata
import io.grpc.ServerCall
import io.grpc.Status
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentLinkedQueue

class LoggingServerCall<RequestType, ResponseType>(
    delegate: ServerCall<RequestType, ResponseType>,
    private val metadata: Metadata,
    private val input: ConcurrentLinkedQueue<RequestType>,
    private val output: ConcurrentLinkedQueue<ResponseType>
) : SimpleForwardingServerCall<RequestType, ResponseType>(delegate) {

    override fun sendMessage(message: ResponseType) {
        output.offer(message)
        super.sendMessage(message)
    }

    override fun close(status: Status, trailers: Metadata) {
        if (status.isOk) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)

            val printer = JsonFormat.printer()

            val request = input
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            val response = output
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            logger.info("The request with id: $requestId and request data $request returns $response")

        } else if (listOf(Status.INTERNAL.code, Status.NOT_FOUND.code, Status.INVALID_ARGUMENT.code).contains(status.code)) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)
            logger.error("An error occurred while processing the request with request-id $requestId", status.asRuntimeException())
        }

        super.close(status, trailers)
    }

    companion object {
        private val logger = LoggerFactory.getLogger(LoggingServerCall::class.java)
        private val REQUEST_ID_METADATA_KEY = Metadata.Key.of("x-request-id", Metadata.ASCII_STRING_MARSHALLER)
    }
} Our implementation is very simple. We use JsonFormater for converting protobuf to JSON and joining to the string. Also, we take a request ID from the metadata for emulating real logging situations. Then we log the message into the system out. If an error occurs, we will log it. After that, the onComplete/onCancel methods of the listener will be called. Next, we must implement our ServerInterceptor which uses both our ServerCall and ServerCall.Listener. class LoggingInterceptor : ServerInterceptor {
    override fun <ReqT : Any, RespT : Any?> interceptCall(
        call: ServerCall<ReqT, RespT>,
        headers: Metadata,
        next: ServerCallHandler<ReqT, RespT>
    ): ServerCall.Listener<ReqT> {
        val input = ConcurrentLinkedQueue<ReqT>()
        val output = ConcurrentLinkedQueue<RespT>()
        val loggingServerCall = LoggingServerCall(call, headers, input, output)
        return LoggingServerCallListener(next.startCall(loggingServerCall, headers), input)
    }
} To start the processing request, we must call the startCall method of the ServerCallHandler class. After that, we must register our server interceptor. fun main(args: Array<String>) {
	val server = ServerBuilder
        .forPort(8080)
		.addService(OurGrpcService())
		.intercept(LoggingInterceptor())
		.build()
	
	server.start()
} In the second part, we consider how to work with client interceptors. I hope the article can help you with how to work with the server-side interceptors in GRPC.

How to Implement Server-Side Interceptors for Logging GRPC Requests

Revealing the Digital Detective: Essential OSINT Tools and Techniques for Investigators

Hello everyone! In the previous articles ( and ), I described my experience with the development of an alerting and state checking system for a service operating on a remote server, with communication occurring through a Telegram bot. This way of communication is convenient because the phone with Telegram is always at hand, and sometimes it's even too much effort to take out the laptop when you can quickly check everything in Telegram. part 1 part 2 In this part, I will describe the process of regularly collecting data and forming graphs on the functioning of the service, which can also be obtained through the bot. After a couple of days of using the service described in previous articles, I felt the need to also get graphs directly in Telegram, rather than going for the laptop, opening csv files in Jupyter notebook, etc. And I thought, why not do it? I had doubts that the graphs would not look very good if created blindly, automatically. For instance, labels might overlap with lines or axes. But in the end, using the Seaborn library instead of the usual Matplotlib, without any special settings, it is possible to achieve quite decent graphs. Let's start as usual with creating a virtual environment: cd ~
virtualenv -p python3.8 up_env 
source ~/up_env/bin/activate and installing the necessary dependencies: pip install python-telegram-bot
pip install "python-telegram-bot[job-queue]" --pre
pip install --upgrade python-telegram-bot==13.6.0 
pip install numpy 
pip install seaborn

pip install web3 # add here anything you need As in the previous article, the file does not undergo any changes in this case and remains the same: functions.py import numpy as np
import multiprocessing

from web3 import Web3 #  add those libraries needed for your task

# Helper function that checks a single node
def get_last_block_once(rpc):
    try:
        w3 = Web3(Web3.HTTPProvider(rpc))
        block_number = w3.eth.block_number
        if isinstance(block_number, int):
            return block_number
        else:
            return None
    except Exception as e:
        print(f'{rpc} - {repr(e)}')
        return None


# Main function to check the status of the service that will be called
def check_service():
    # pre-prepared list of reference nodes
    # for any network, it can be found on the website https://chainlist.org/
    list_of_public_nodes = [
        'https://polygon.llamarpc.com',
        'https://polygon.rpc.blxrbdn.com',
        'https://polygon.blockpi.network/v1/rpc/public',
        'https://polygon-mainnet.public.blastapi.io',
        'https://rpc-mainnet.matic.quiknode.pro',
        'https://polygon-bor.publicnode.com',
        'https://poly-rpc.gateway.pokt.network',
        'https://rpc.ankr.com/polygon',
        'https://polygon-rpc.com'
    ]
    
    # parallel processing of requests to all nodes
    with multiprocessing.Pool(processes=len(list_of_public_nodes)) as pool:
        results = pool.map(get_last_block_once, list_of_public_nodes)
        last_blocks = [b for b in results if b is not None and isinstance(b, int)]

    # define the maximum and median value of the current block
    med_val = int(np.median(last_blocks))
    max_val = int(np.max(last_blocks))
    # determine the number of nodes with the maximum and median value
    med_support = np.sum([1 for x in last_blocks if x == med_val])
    max_support = np.sum([1 for x in last_blocks if x == max_val])

    return max_val, max_support, med_val, med_support A significant difference from the two previous scripts to launch the bot is that to create a graph and then send it through the bot, you first need to collect data, or rather, collect it at some regularity. Since, unlike alerting, here I want the data to be written regardless of the operability of the bot itself (for example, downtime during bot updates), the script for data collection will be put into a separate file and will be run through cron at some regularity. So, the code for the data collection script : data_collection.py import datetime 
import csv

# Import necessary functions
from functions import get_last_block_once, check_service

# File path for logging
LOG_FILE = '../logs.csv'
# Address of the node whose state I am monitoring (public node in this case)
OBJECT_OF_CHECKING = 'https://polygon-mainnet.chainstacklabs.com'

# Function to save one measurement to a CSV file
def save_log(log_data):
    with open(LOG_FILE, mode='a', newline='') as log_file:
        log_writer = csv.writer(log_file)
        log_writer.writerow(log_data)


if __name__ == '__main__':
    # Call the main function for checking the network state
    max_val, max_support, med_val, med_support = check_service()
    # Call the function for checking the state of the node being monitored
    last_block = get_last_block_once(OBJECT_OF_CHECKING)

    # Current date and time
    timestamp_string = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    # Formulate data string and save to file
    log_data = [timestamp_string, max_val, max_support, med_val, med_support, last_block]
    save_log(log_data) This script is run through cron with a regularity, for example, every 5 minutes. To open cron settings: crontab -e In the settings file, we save the line to run the script in the created environment, and separately log errors in another file: up_env * * * * *  cd ~; source up_env/bin/activate; cd /path/to/script; python data_collection.py >> ~/collect.log 2>&1 As stated in the file, data will be saved in the file. We will use them to build graphs. Now let's move on to the script describing the work of the Telegram bot. Import the necessary dependencies and set the constants: data_collection.py ../logs.csv import telegram 
from telegram.ext import Updater, CommandHandler, Filters

# For reading data and building charts
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

import datetime
import io

# Here I can specify a limited circle of bot users by listing their usernames
ALLOWED_USERS = ['your_telegram_account', 'someone_else']
# The node address whose status I am tracking (also a public node in this case)
OBJECT_OF_CHECKING = 'https://polygon-mainnet.chainstacklabs.com'
# Threshold for highlighting critical lag
THRESHOLD = 5
# Data file
LOG_FILE = '../logs.csv' We describe a function that collects a graph and sends it to the user: def send_pics(update, context, interval):

    try:
        # Get the user
        user = update.effective_user

        # Filter out bots (just in case)
        if user.is_bot:
            return

        # Check if the user is in the allowed list 
        username = str(user.username)
        if username not in ALLOWED_USERS:
            return
    except Exception as e:
        print(f'{repr(e)}')
        return

    # Read data from a file (file does not have a header)
    df = pd.read_csv(LOG_FILE, header=None, names=[
        'timestamp_string', 'max_val', 'max_support', 'med_val', 'med_support', 'block_number'
    ])
    # Convert a string to a date/time type
    df['timestamp'] = pd.to_datetime(df['timestamp_string'])

    # Determine the starting point from which the data will be reflected on the graph
    now = datetime.datetime.now()
    # Multiple intervals are available - week, day, hour
    if interval == 'week':
        one_x_ago = now - datetime.timedelta(weeks=1)
    elif interval == 'day':  # day
        one_x_ago = now - datetime.timedelta(days=1)
    else:
        one_x_ago = now - datetime.timedelta(hours=1)
    # Filter the dataframe
    df = df[df['timestamp'] >= one_x_ago]

    # Create columns with lags for the selected node and for the node with the highest block value
    cols_to_show = ['node_lag', 'best_node_lag']
    df['node_lag'] = df['block_number'] - df['med_val']
    df['best_node_lag'] = df['max_val'] - df['med_val']

    # Create a graph with seaborn
    plt.figure()
    sns.set(rc={'figure.figsize': (11, 4)})  # set figure size
    sns.lineplot(x='timestamp', y='value', hue='variable', data=df[['timestamp']+cols_to_show].melt('timestamp', var_name='variable', value_name='value'))
    # Add a "corridor" for easier comparison with the threshold
    plt.axhline(y=THRESHOLD, color='black', linestyle='--')
    plt.axhline(y=-THRESHOLD, color='black', linestyle='--')

    # Save the image to a buffer
    buf = io.BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)

    # Send the image to the user
    context.bot.send_photo(chat_id=user.id, photo=buf)

    # "Close" the graph object
    plt.close() In this case, in the code, you can choose intervals for display: hour day week Their selection is carried out through the corresponding bot commands , , , which look like this in the code: /hour /day /week # Handler for the command to display the chart for the last hour
def hour(update, context):
    send_pics(update, context, 'hour')

# Handler for the command to display the chart for the last day
def day(update, context):
    send_pics(update, context, 'day')

# Handler for the command to display the chart for the last week
def week(update, context):
    send_pics(update, context, 'week') All that remains is to initialize the bot and "bind" the commands to their handlers: # Your Telegram bot token obtained through BotFather
token = "xxx"

# Create a bot instance
bot = telegram.Bot(token=token)
updater = Updater(token=token, use_context=True)
dispatcher = updater.dispatcher


# Connect command handlers to the bot's commands
dispatcher.add_handler(CommandHandler("hour", hour, filters=Filters.chat_type.private))
dispatcher.add_handler(CommandHandler("day", day, filters=Filters.chat_type.private))
dispatcher.add_handler(CommandHandler("week", week, filters=Filters.chat_type.private))

# Start the bot
updater.start_polling() In addition to this, for convenience, you can add real buttons for commands via BotFather. Finally the result looks like this: PS . I noticed that the labels under the time axis were overlapping, but this problem can be easily solved by adding a rotation of 15 degrees with the command "plt.xticks(rotation=15)", executed after plotting the graphs. That's all, if there are any questions, I will be glad to answer them. The source code of the project is available in the on GitHub. If this tutorial seemed useful to you, feel free to put a star on GitHub, I would appreciate it 🙂 repository

How to Create a Telegram Bot for Monitoring Your Service Uptime in Python (Part 3: Getting Graphs)

If your business has ever considered adding a payment system for issuing cards—perhaps to customers or employees—then you may have avoided it because the technical hurdles seemed too difficult. In reality, getting a payment system up and running is quite straightforward. In this post, we’ll look at how to build payments into your Java application using the from . Core API Marqeta Marqeta is a financial services company that you’ve likely already benefited from using their platform. , , and all have payment platforms built out using Marqeta. If your company needs to issue payment methods to customers or employees, then this platform may be exactly what you need. Uber Square DoorDash We’ll walk through building out a fully functioning card payment system that starts with a bank or other financial institution and ends with a customer or employee with a card they can use for payments anywhere that a debit or credit card is accepted. Before we get going on the technology, it’s important first to cover some of the key terms in use at Marqeta. Key Terms at Marqeta Marqeta partners with a bank to provide a . This source will be a place from which money can be drawn any time a transaction is carried out by the who has a issued to them. A cardholder is any user who holds a card—which can be physical or virtual. funding source user card The rules that govern how a card is to be used  are encapsulated in a . Card products include information related to all cards associated with them, such as whether cards are physical or virtual, single-use or multiple-use, and what is required to complete a transaction. card product All of these important pieces of the Marqeta ecosystem can be managed via the Core API. In our simple Java application, we’ll , , and (based on the card product we created) to the user we created—all by using the Core API. From the perspective of your cardholders, everything will be happening within the app that we’re going to build, so there’s no need for them to interact with Marqeta at all. create a new card product create a user issue a virtual card Java and the Core API While there’s not an officially supported Java SDK for Marqeta, is quite straightforward, as the Core API is documented in both and . The OpenAPI documentation is in beta, but it is generated directly from the API source code. To get a Java client, all we need to do is drop the OpenAPI yaml file into , modify the servers section to use the as the URL, and tell it to generate a Java client. building a Java client Swagger v2.0 OpenAPI v3.0 editor.swagger.io https://sandbox-api.marqeta.com/v3 Building the Client Once you’ve downloaded the client, you can build the client in your local Maven repository, get a Maven app started, and include the client in your file. pom.xml Newer versions of Java may require adding a dependency to the client’s : pom.xml 
<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency> To build the client, we run this command from within the client’s folder: $ mvn clean install Then, in a clean working folder for our app, we run this command: $ mvn -B archetype:generate \
    -DgroupId=com.mycompany.app \
    -DartifactId=my-payment-app \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DarchetypeVersion=1.4 You’ll now have a folder called with a into which you can add the generated client as a dependency: my-payment-app pom.xml <dependency>
  <groupId>io.swagger</groupId>
  <artifactId>swagger-java-client</artifactId>
  <version>1.0.0</version>
  <scope>compile</scope>
</dependency> Creating the Java Payment App Now that you’ve created your app’s skeleton, let’s look at the meat of getting started with Marqeta’s Core API. In fact, we’re going to be working through a lot of the steps of the . If you’d prefer to work through that guide, you won’t need to write any code at all, as it includes a built-in . The explorer is also a great way to double check your work as you go through this article. Core API Quick Start guide API Explorer Imports and authentication We can get started in the main file of the Maven-generated app by setting up our authentication and importing the classes we’ll use throughout the project. App.java package com.mycompany.app;

import io.swagger.client.*;
import io.swagger.client.api.*;
import io.swagger.client.model.*;

public class App
{
   public static void main( String[] args )
   {
       String username = "your-sandbox-application-token";
       String password = "your-sandbox-admin-access-token";

       ApiClient apiClient = new ApiClient();
       apiClient.setUsername(username);
       apiClient.setPassword(password);
  }
} Of course, in a production application, you wouldn’t want to include your authentication tokens in plaintext in your code. However, for learning purposes in this demo setup, doing so will allow us to get going quickly. You can find the values you need in your . Marqeta Sandbox Dashboard Create a user Once we have this object ready to go, we can create a new user record with the : ApiClient UsersAPI ...
       apiClient.setPassword(password);

       UsersApi usersApiInstance = new UsersApi();
       usersApiInstance.setApiClient(apiClient);
       CardHolderModel cardHolderBody = new CardHolderModel();

       cardHolderBody.setFirstName("Marqeta");
       cardHolderBody.setLastName("User");
       cardHolderBody.setAddress1("180 Grand Avenue");
       cardHolderBody.setAddress2("6th Floor");
       cardHolderBody.setCity("Oakland");
       cardHolderBody.setState("CA");
       cardHolderBody.setPostalCode("94612");

       String userToken = "";

       try {
           UserCardHolderResponse cardHolderResult = usersApiInstance.postUsers(cardHolderBody);
           System.out.println(cardHolderResult);
           userToken = cardHolderResult.getToken();
           System.out.println("USER TOKEN: " + userToken);
       } catch (ApiException e) {
           System.err.println("Exception when calling UsersApi#postUsers");
           e.printStackTrace();
       }
... Note that we’ve set the user’s first and last name, and we’re storing the user token that gets returned so we can use it later. We also configured the to use the that we defined previously. We’ll continue to do that for each new API endpoint we interact with. usersApiInstance APIClient Create or use an existing card product At this point, we can look for an appropriate card product for issuing a card to our user. Fortunately, the sandbox provides us with a card product called “Reloadable Card”, so we can search for that card product and save its token. This card product also has a funding type attached to it, so we don’t need to do anything special to create one. ...
       CardProductsApi cardProductsApiInstance = new CardProductsApi();
       cardProductsApiInstance.setApiClient(apiClient);

       Integer count = 1;
       Integer startIndex = 0;
       String sortBy = "-createdTime";

       String cardProductToken = "";

       try {
           CardProductListResponse cardProductListResult = cardProductsApiInstance.getCardproducts(count, startIndex, sortBy);
           System.out.println(cardProductListResult);
           cardProductToken = cardProductListResult.getData().get(0).getToken();
           System.out.println("CARD PRODUCT TOKEN: " + cardProductToken);
       } catch (ApiException e) {
           System.err.println("Exception when calling CardProductsApi#getCardProducts");
           e.printStackTrace();
       }
... Issue a card At this point, we have everything we need—a and a —to issue a new card. We make sure to tell the API to send us the CVV or the PAN for the card upon generation, for greater security. user token card product token not ...
       CardsApi cardsApiInstance = new CardsApi();
       cardsApiInstance.setApiClient(apiClient);

       CardRequest cardRequestBody = new CardRequest();
       cardRequestBody.setUserToken(userToken);
       cardRequestBody.setCardProductToken(cardProductToken);

       Boolean showCvvNumber = false;
       Boolean showPan = false;

       try {
           CardResponse cardResult = cardsApiInstance.postCards(cardRequestBody, showCvvNumber, showPan);
           System.out.println(cardResult);
       } catch (ApiException e) {
           System.err.println("Exception when calling CardsApi#postCards");
           e.printStackTrace();
       }
... Simulate transactions and see history Now that you’ve created a card for your user, you can . The existing card product we used already has a , but you can also make API calls to make sure that a user is properly funded to make payments with their card. simulate some transactions against that card funding source Then, you can view account balances and a history of transactions in the tool in your dashboard. This will help you get a sense of what exactly goes on when transactions are carried out against a card on Marqeta. Transaction Timeline Webhooks Marqeta’s Core API also implements , which allow your application or systems to be notified whenever certain events take place. Webhooks can help you connect activity in your application (like the issuing of a card or a declined transaction) with triggers to run backend processes or notify your users. webhooks Conclusion Integrating payments into your application—whether it’s in Java, Python, JavaScript, or another language—isn’t as daunting of a task as you might think. With Marqeta’s Core API—available in OpenAPI format—coupled with its and the , building a payment application is a straightforward project you can tackle quickly. documentation API Explorer Also published . here

A Guide to Building a Java Payment App Using Marqeta

WebSockets are a technology for creating real-time, bi-directional communication channels over a single TCP connection. They help build applications that require low-latency, high-frequency communication, such as chat applications, online gaming, and collaborative software. In this tutorial, we will be building a real-time chat application using WebSockets and the Socket.IO library. We will use Node.js as the server-side language and React as the client-side technology. However, the principles discussed in this tutorial can be applied to any language or technology that supports WebSockets. Prerequisites Before we begin, you should have the following prerequisites: Basic understanding of JavaScript Basic understanding of Node.js and React Basic understanding of web development concepts, such as HTTP and HTML Node.js and npm installed on your machine React developer tools installed in your browser (optional, but helpful for debugging) Setting up the Server First, let's create a new directory for our project and navigate to it in the terminal. mkdir real-time-chat-app
cd real-time-chat-app Next, let's create a new Node.js project by running the following command: npm init -y This will create a file in our project directory. package.json Next, we need to install the Socket.IO library, which will handle the WebSocket communication for us. Run the following command to install it: npm install socket.io Now let's create a new file called in the root of our project directory. This will be the entry point for our server-side code. server.js In , we first need to require the and modules: server.js HTTP socket.io const http = require('http');
const io = require('socket.io'); Next, let's create an HTTP server and bind it to a port. We will use port 3000 for this example, but you can choose any available port on your machine. const server = http.createServer((req, res) => { res.end('Server is running!');
});
const port = 3000;
server.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
}); Now if we run the server by running in the terminal and navigate to in the browser, we should see the message "Server is running!". node server.js http://localhost:3000 Next, we need to attach the Socket.IO server to our HTTP server. We do this by calling the method on the object, and passing it to our HTTP server as an argument: listen io const ioServer = io.listen(server); Now that we have set up the server, let's move on to setting up the client-side code. Setting up the Client First, let's create a new directory called in the root of our project directory. This is where we will store the client-side code for our chat application. client Next, let's create a new React project in the directory. Run the following command in the directory: client client npm start Once you have created a new React project in the directory, you should have a and directory inside the directory. client public src client Inside the directory, create a new file called . This will be the root component of our chat application. src App.js First, let's import the required dependencies: import React, { useState, useEffect } from 'react'; import io from 'socket.io-client'; Next, let's create a function called that will handle the WebSocket communication for us. useWebSocket This function will return an object with three properties: : an array of messages that have been received from the server messages : a function that can be called to send a message to the server sendMessage : an error object that will be set if there is an error in the WebSocket connection error Add the following code to : App.js function useWebSocket() {   const [messages, setMessages] = useState([]);   const [error, setError] = useState(null);   useEffect(() => {     const socket = io('http://localhost:3000');     socket.on('connect', () => {       console.log('Connected to server!');     });     socket.on('disconnect', () => {       console.log('Disconnected from server');     });     socket.on('error', (error) => {       setError(error);     });     socket.on('message', (message) => {       setMessages((prevMessages) => [...prevMessages, message]);     });     return () => {       socket.disconnect();     };   }, []);   const sendMessage = (message) => {     if (socket.connected) {       socket.send(message);     }   };   return { messages, sendMessage, error }; } This code uses the hook to set up the WebSocket connection when the component mounts. We are also using the hook to keep track of the and state. useEffect useState messages error The function returns an object that contains the array, the function, and the object. useWebSocket messages sendMessage error Now let's use the function in our component. Add the following code to : useWebSocket App App.js function App() {
   const { messages, sendMessage, error } = useWebSocket();   if (error) {     return <div>Error: {error.message}</div>;   }   return (     <div>       <ul>         {messages.map((message) => (           <li>{message}</li>         ))}       </ul>       <form onSubmit={(event) => {         event.preventDefault();         const messageInput = event.target.elements.message;         sendMessage(messageInput.value);         messageInput.value = '';       }}>         <input name="message" />         <button type="submit">Send</button> function App() {   const { messages, sendMessage, error } = useWebSocket();   if (error) {     return <div>Error: {error.message}</div>;   }   return (     <div>       <ul>         {messages.map((message) => (           <li>{message}</li>         ))}       </ul>       <form onSubmit={(event) => {         event.preventDefault();         const messageInput = event.target.elements.message;         sendMessage(messageInput.value);         messageInput.value = '';       }}>         <input name="message" />         <button type="submit">Send</button>       </form>     </div>   ); }
 export default App; Now let's move on to handling the messages on the server side. Handling Messages on the Server In the file, let's add the following code to handle incoming messages: server.js ioServer.on('connection', (socket) => {   console.log('New client connected');   socket.on('message', (message) => {     console.log(`Received message from client: ${message}`);     ioServer.emit('message', message);   });   socket.on('disconnect', () => {     console.log('Client disconnected');   }); }); In this code, we use the connection event to handle new clients connecting to the server. We are also using the event to handle incoming messages from the client and the event to handle clients that disconnect from the server. message disconnect When a message is received, we simply log it to the console and then emit it back to all connected clients using the method. emit Now, if you start the server by running and navigate to in the browser, you should be able to send messages and see them displayed in real-time. node server.js http://localhost:3000 Conclusion This tutorial taught us how to create a real-time chat application using WebSockets and the Socket.IO library. We have set up a Node.js server and a React client and implemented the WebSocket communication using the hook on the client side and the , , and events on the server side. useWebSocket connection message disconnect You can extend this application in many ways, such as adding user authentication, storing messages in a database, and implementing more advanced features like message editing and deletion. I hope this tutorial has provided a good foundation for you to build on. Helpful Resources Microsoft websockets Basics of Websockets Also published here.

Stories, News & Mentions about IMPORTIO

Importio’s Stories on HackerNoon

Importio's News & Mentions