gRPC एक शक्तिशाली, उच्च प्रदर्शन वाली रिमोट प्रोसीजर कॉल (RPC) फ्रेमवर्क है, जो REST की तुलना में कम उपयोग होने के बावजूद, कुछ परिदृश्यों में महत्वपूर्ण लाभ प्रदान करता है।

इसके अलावा यह भाषा अज्ञेयवादी है और किसी भी वातावरण में चल सकती है, जो इसे सर्वर-टू-सर्वर संचार के लिए एक आदर्श विकल्प बनाती है।

मैं इसकी पूरी व्याख्या में नहीं जाऊंगा लेकिन यहां जीआरपीसी का एक सामान्य लिंक है। मैं ट्यूटोरियल पर एक हाथ प्रदान करूंगा

जीआरपीसी क्लाइंट पर जाएं 

आइए कल्पना करें कि हमारा गो क्लाइंट है लेकिन फ्रंटएंड ऐप रिएक्ट, स्वेल्ट आदि के लिए एक सर्वर है।

func getFirstArg() (string, error) {
    if len(os.Args) 






उदाहरण के तौर पर रिएक्ट फ्रंटएंड एक फ़ाइल अपलोड करता है, इसे प्रोसेस करें लेकिन हमें एक्सेल से उत्तर चाहिए हम जीपीटी एपीआई का उपयोग करेंगे। जबकि यह गो के साथ किया जा सकता है, दूसरी ओर पायथन के पास अधिक पैकेज हैं जो हमारे जीवन को आसान बना सकते हैं जैसे langchan_openai, एक्सेल के लिए पांडा इत्यादि।


आइए अधिमानतः आपके वर्चुअलएन्व .venv में जीआरपीसी की स्थापना के साथ शुरुआत करें


$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
$ export PATH="$PATH:$(go env GOPATH)/bin"




अगला, आपको अपने ओएस में प्रोटोकॉल बफ़र इंस्टॉल करना चाहिए, यहां इसका अनुसरण कर सकते हैं।

आइए एक प्रोटो डीआईआर बनाएं जहां आप अपनी प्रोटोकॉल बफ़र फ़ाइल संग्रहीत करेंगे, मैं इसे excel.proto नाम दूंगा और इसे पेस्ट करूंगा:


syntax = "proto3";
option go_package = "client-gRPC/proto";
service ExcelService {
    rpc UploadFile(FileRequest) returns (FileResponse);
}
message FileRequest {
    string file_name = 1;
    bytes file_content = 2;
}
message FileResponse {
    bytes file_content = 1;
}




यह जीआरपीसी सेवा, एक्सेलसर्विस, ग्राहकों को अपना नाम और सामग्री भेजकर एक फ़ाइल अपलोड करने की अनुमति देती है। सर्वर उसी फ़ाइल सामग्री के साथ प्रतिक्रिया करता है। 

गो के लिए पायथन में go_package में पास होना आवश्यक है, लाइन की आवश्यकता नहीं है।


यदि आप VSCode का उपयोग करते हैं तो डाउनलोड करने के लिए vscode-proto3 एक अच्छा एक्सटेंशन है।


इस सब के बाद आप अपनी प्रोटो फ़ाइलें जेनरेट कर सकते हैं, मैं इसे प्रोट डीआईआर के समान स्तर पर रखना पसंद करता हूं, इसके लिए यह कमांड चलाएं:

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative proto/excel.proto

यदि सफलतापूर्वक दो फ़ाइलें उत्पन्न की जानी चाहिए, वैकल्पिक रूप से यदि बहुत सारे समायोजन होंगे तो एक मेकफ़ाइल जोड़ें और इसे प्रोटो अपर कमांड के रूप में परिभाषित करें।


import (
    ....

    "google.golang.org/grpc"
    pb "client-gRPC/proto"
    "github.com/xuri/excelize/v2"
)

func main() {
    ....

    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Failed to connect to gRPC server: %v", err)
    }
    defer conn.Close()

    client := pb.NewExcelServiceClient(conn)

    req := &pb.FileRequest{
        FileName:    filePath,
        FileContent: fileData,
    }

    res, err := client.UploadFile(context.Background(), req)
    if err != nil {
        log.Fatalf("Failed to upload file: %v", err)
    }

    outputFile := "output.xlsx"
    err = saveBytesAsExcel(outputFile, res.FileContent)
    if err != nil {
        log.Fatalf("Failed to save bytes as Excel file: %v", err)
    }

    fmt.Printf("Excel file saved as: %s\n", outputFile)
}

func saveBytesAsExcel(filePath string, fileContent []byte) error {
    f, err := excelize.OpenReader(bytes.NewReader(fileContent))
    if err != nil {
        return fmt.Errorf("failed to open Excel file: %v", err)
    }

    if err := f.SaveAs(filePath); err != nil {
        return fmt.Errorf("failed to save Excel file: %v", err)
    }
    return nil
}




 हम 50051 को सुनने के लिए एक कनेक्शन बनाते हैं जो हमारा पायथन सर्वर होगा, &pb.FileRequest पहले प्रोटो कमांड का उपयोग करके उत्पन्न किया गया था और अब हम तरीकों को आयात कर रहे हैं। यदि आप दौड़ेंगे तो आपको प्राप्त होगा? पायथन सर्वर अभी तक स्थापित नहीं होने के कारण।


Failed to upload file: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing: dial tcp 127.0.0.1:50051: connect: connection refused"





  
  
  पायथन जीआरपीसी सर्वर


चूंकि पायथन एक सर्वर के रूप में कार्य करेगा, दृष्टिकोण थोड़ा अलग होगा लेकिन संक्षेप में पैकेज फ़ील्ड से अलग एक ही प्रोटो फ़ाइल की आवश्यकता नहीं है। आइए, जीआरपीसी के बिना एक आधार main.py बनाकर शुरुआत करें ताकि यह देखा जा सके कि जीपीटी एक्सेल में प्रश्नों को कैसे पॉप्युलेट करेगा।


import os
import openai
import pandas as pd
from dotenv import load_dotenv

def get_answer_from_gpt(apikey: str, question: str):
    openai.api_key = apikey
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": question}
        ]
    )
    return response['choices'][0]['message']['content'].strip()

def answer_questions_df(df: pd.DataFrame, apikey: str):
    answers = []

    for question in df.iloc[:, 0]: 
        answer = get_answer_from_gpt(apikey, question)
        answers.append(answer)
    return answers

if __name__ == "__main__":
    load_dotenv()

    openai_api_key = os.getenv("OPENAI_API_KEY", "OpenAI API key hasn't been set.")

    df = pd.read_excel('Book1.xlsx')

    df['Answer'] = answer_questions_df(df, openai_api_key





यह एक सरल स्क्रिप्ट है जो उन प्रश्नों का उत्तर देगी जो गो हमें भेजेगा लेकिन समर्पित ओपनाई लाइब्रेरी के कारण एलओसी कम है जो इसे आसान बनाती है।


हम प्रोटो डीआईआर को उसी फ़ाइल के साथ जोड़कर शुरू करते हैं जैसा ऊपर बताया गया है कि विकल्प अनुभाग को चर्चा के अनुसार हटाया जा सकता है। अधिमानतः अपने वर्चुअलएन्व में जीआरपीसी स्थापित करें और मेरे द्वारा चलाए गए प्रोटो जनरेशन के लिए यहां इंस्टालेशन का पालन करें"


python3 -m grpc_tools.protoc --proto_path=proto --python_out=proto --grpc_python_out=proto proto/excel.proto




मेरी प्रोटो निर्देशिका के समान स्तर पर होने के लिए __init.py जोड़ना याद रखें!

फ़ाइलें तैयार हो गई हैं तो आगे बढ़ते रहें।


import io
import grpc
from proto import excel_pb2_grpc as excel_grpc
from proto import excel_pb2

class ExcelService(excel_grpc.ExcelServiceServicer):
    def UploadFile(self, request, context):
        try:
            # Convert bytes to a file-like object
            file_like_object = io.BytesIO(request.file_content)

            # Load the workbook from the file-like object
            workbook = openpyxl.load_workbook(file_like_object)

            # Access the first sheet (or use appropriate logic to get the sheet you need)
            sheet = workbook.active

            # Convert the sheet to a DataFrame
            data = sheet.values
            columns = next(data)  # Get the header row
            df = pd.DataFrame(data, columns=columns)

            print("Loaded DataFrame:")
            print(df.head())

            # Ensure that the DataFrame is not empty and has questions
            if df.empty or df.shape[1] 



 हम सर्वर को परिभाषित करते हैं और ExcelService क्लास जोड़ते हैं जिसमें प्रोटो फ़ाइल द्वारा उत्पन्न विधियाँ शामिल होती हैं। चूँकि हम फ़ाइल को बाइट्स द्वारा प्राप्त करते हैं, इसलिए हमें io बाइट रीडर का उपयोग करना होगा और फ़ाइल की आगे की प्रक्रिया शुरू करनी होगी और दूसरे कॉलम को पॉप्युलेट करना होगा।


response = excel_pb2.FileResponse(file_content=output.read())




अंत में हम अपने गो क्लाइंट को प्राप्त करने के लिए ☝️ लौटा रहे हैं।


पाइथन में प्रोटो फ़ाइलें ढूंढने में सक्षम होने के लिए आपको एक निर्यात पथ परिभाषित करना चाहिए

export PYTHONPATH=$PYTHONPATH:mnt/c/own_dev/gRPC/server/proto



  
  
  क्लाइंट और सर्वर चलाना




If all is good you can run

#First comes server

python3 -m main

#Then client

go run client.go Book1.xlsx




और आपको गो क्लाइंट साइड में अपडेटेड .xlsx फ़ाइल मिलनी चाहिए।


  
  
  निष्कर्ष


इस लेख में हमने पायथन सर्वर और गो क्लाइंट के बीच जीआरपीसी संचार स्थापित करने के बुनियादी सिद्धांतों का पता लगाया। जीआरपीसी का लाभ उठाकर, हमने एक एक्सेल फ़ाइल को गो एप्लिकेशन से पायथन सर्वर पर भेजने, ओपनएआई के जीपीटी एपीआई का उपयोग करके फ़ाइल को संसाधित करने और संशोधित फ़ाइल को गो क्लाइंट पर वापस लौटाने का एक सहज तरीका स्थापित किया है।