import csv
    import sys
    import logging
    from azure.storage.blob import BlobServiceClient
    from azure.storage.blob import BlobClient
    from azure.storage.blob import ContainerClient
    import azure.functions as func
    import pika
    import os
    import json
    import pandas
    from reader import Reader
    from io import StringIO, BytesIO
    import pyxlsb
    import openpyxl
    import requests 

    def main (myblob: func.InputStream, msg: func.Out[func.QueueMessage], inputblob: func.InputStream):
        # dblob = myblob
        logging.info(f"Python blob trigger function processed blob \n"
                 f"Name: {myblob.name}\n"
                 f"Blob Size: {myblob.length} bytes")`

    name = myblob.name

        print(name)

        if ".csv" in name:
            #      # Convert blob to json
            conn_str = os.environ['nameofstorageconnectionvariable']
            container = os.environ["nameofcontainernamevariable"]
            blob_name = myblob.name.split("/",1)[-1]
            container_client = ContainerClient.from_connection_string( conn_str=conn_str, 
            container_name=container)
            downloaded_blob = container_client.download_blob(blob_name)
            df = pandas.read_csv(StringIO(downloaded_blob.content_as_text()), sep=',', engine="python")

     df = pandas.read_csv(StringIO(downloaded_blob.content_as_text()), sep=',', engine="python")

            index = df.index
            rowamount = len(index-1)
            print("Here is the rows count ---------------->", rowamount) 

            batchdelimeter = 5000
            line = 0
            x = 1

            if batchdelimeter != 1:
                batchcounter = rowamount//batchdelimeter
                if(rowamount%batchdelimeter) !=0:
                    batchcounter = batchcounter + 1

            else:
                batchcounter = rowamount
                x = 0

            print("here is the batch count--------->", batchcounter)

            for batch in range(batchcounter):
                if (batch==batchcounter):
                    iter=rowamount
                else:
                    iter=(x*batchdelimeter)

                x= x+1

                print("starting with the batch # ---------------->", batch)
                print("the line------->", line)
                print("the iterator------>", iter)
                print("the loc", df.loc[line:iter]) 
                linerecord = df.loc[line:iter]
                print("ending with the batch  # ---------------->", batch )    
                line=iter+1
                lastflag = False

                if batch == (batchcounter - 1):
                    lastflag = True

            # for line in range(batch):
                result = linerecord.to_json(orient='records')
                parsed = json.loads(result)
                dumpresults = json.dumps(parsed, indent=4)
                messagebatchcounter = batchcounter
                stringcount = str(messagebatchcounter)

                if "FILENAMECONDITION" in name:
                    msg = '{ INSERT JSON HERE }'  
                    key = "vendor"

                r = requests.post(api_url, data=msg)

  package main

    import (
        "encoding/json"
        "fmt"
        "io"
        "log"
        "net"
        "time" 

        "github.com/streadway/amqp"
   ) 

    func main() {

    fmt.Println("Connecting to RabbitMQ")
        url := "RABBIT-URL-GOES-HERE"
        connection, err := amqp.Dial(url)

        if err != nil {
            fmt.Println("Error connecting with dial: ", err)
        }

        defer connection.Close()
        channel, err := connection.Channel()

        if err != nil {
            fmt.Println("Could not create channel from rabbit connection: ", err)
        }

        defer channel.Close()
        queueName := "QUEUE-NAME-GOES-HERE"

    // The variable m is used here to declare the type of rabbitmq we are using. This is a solution to the error, "inequivalent arg 'x-queue-type' for queue 'queuename' in vhost '/': received none but current is the value 'classic' of type 'longstr"

    m := make(amqp.Table)
        m["x-queue-type"] = "classic" 

        q, err := channel.QueueDeclare(
            queueName, //name
            true,      //durable
            false,     //deleted when unused
            false,     // exclusive
            false,     //no-wait
            m,         //arguments
        )

        if err != nil {
            fmt.Println("Error declaring queue: ", err)
        }

        msgs, err := channel.Consume(
            q.Name, //queue
            "",     //consumer
            true,   //auto-ack
            false,  //exclusive
            false,  //no-local
            false,  //no-wait
            nil,    //args
        )

    }

package main

    import (
        "context"
        "encoding/json"
        "fmt"
        "strconv"
        "time" 

        "go.mongodb.org/mongo-driver/bson"
        "go.mongodb.org/mongo-driver/bson/primitive"
        "go.mongodb.org/mongo-driver/mongo"
        "go.mongodb.org/mongo-driver/mongo/options"
    ) 

    type Message struct {
        Name  string json:"Name" bson:"Name"
        Value string json:"Value" bson:"Value"
    } 

    var db *mongo.Client
    var CRUDdb *mongo.Collection
    var mongoCTX context.Context 

    func main() {

        msgs, err := channel.Consume(
            q.Name, //queue
            "",     //consumer
            true,   //auto-ack
            false,  //exclusive
            false,  //no-local
            false,  //no-wait
            nil,    //args
        )

        /////code block from above

        //connecting to MongoDB
        fmt.Println("connecting to MongoDB......")
        mongoCTX = context.Background()
        db, err = mongo.Connect(mongoCTX, options.Client().ApplyURI("DB-URI-GOESS-HERE"))
        if err != nil {
            fmt.Println("Failed with applying URI", err)
            log.Fatal(err)
        } 

        err = db.Ping(mongoCTX, nil)

        if err != nil {
            fmt.Println("Failed to connect to db", err)
            log.Fatal(err)
        } else {
            fmt.Println("Connected to mongo")
        } 

        CRUDdb = db.Database("DB-NAME-GOES-HERE").Collection("COLLECTION-NAME-GOES-HERE")

        // starting a go func to handle the range of messages efficiently

        go func() {
            for d := range msgs {
                msgCount++
                var messagestruct Message 

                fmt.Printf("\nMessage Count: %d, Message Body: %s\n", msgCount, d.Body)

                //here we're essentially "mapping" (unmarshaling) the content of the message to the struct we declared above

                err := json.Unmarshal(d.Body, &messagestruct)

                if err != nil {
                    fmt.Println("Error unmarshaling message body to message struct", err)
                }

                result, err := CRUDdb.InsertOne(ctx, messagestruct)

                if err != nil {
                    fmt.Println("Error Inserting Document ----> ", err)
                }

                fmt.Println("Here is the create result ", result)
            }
        }() 

    }