Jurny, a leading provider of AI-powered solutions for automating hotel and short-term rental management, announced a new integration with Vrbo today. This enhanced collaboration brings several industry-first features in guest communication and reservation management to the market.

Jurny and Vrbo Partner to Automate Short-Term Rental Management; Unveil Industry’s Most Comprehensive Unified Guest Inbox

Liverpool went five points clear at the top of their Europa League group on Thursday night. Jurgen Klopp’s Reds ran out 5-1 winners over Toulouse in their Group E clash at Anfield. Darwin Nunez got on the scoresheet for Liverpool alongside Diogo Jota,

'Laughable': Sky pundit couldn't believe what he saw from £140k-a-week Liverpool player tonight

There is a lot that you want to do b... With so much going on around you, you are easil... Many hands make the work lighter. Accepting help will get the job done far more quickly. This wil... Many hands make the work lighter. Accepting hel...

Leo - July 23 - August 23 - Jul 23 - Aug 23

With so much going on around you, you are easily distracted. There is a lot that you want to do b... With so much going on around you, you are easil... Many hands make the work lighter. Accepting help will get the job done far more quickly. This wil...

The family of Olympic gymnastics champion Mary Lou Retton says she is making “remarkable” progress in her battle with a rare form of pneumonia that landed her in intensive care. McKenna Kelley ...

Family of Olympic champion gymnast Retton says she is making 'remarkable' progress

Ameren customers have a special offer to help manage their energy bill with the Sensi Smart Thermostat, which pairs with an app on their phone to help them manage their energy use quickly and

Ameren wants to help you manage your energy bills with a free Sensi Smart Thermostat – order by October 31!

Olympic gymnastics champion Mary Lou Retton has pneumonia and is in intensive care in a Texas hospital. Retton's daughter, McKenna Kelley, shared Retton's condition in an Instagram post on Tuesday ...

Olympic gymnastics champion Mary Lou Retton is in intensive care with pneumonia

Easil

easil

In this article, I’ll guide you through C# Testcontainers for MongoDB! I love using Testcontainers for local database work when I don’t want to think about managing the overhead of spinning up and tearing down a database, or managing something in the cloud. MongoDB is no exception here as the C# Testcontainers NuGet package that we have for MongoDB is a dream to work with. In this article, I’ll introduce you to the basics of Testcontainers. From there, I’ll demonstrate how simple it is to interact with your newly created database via the C# MongoDB.Driver NuGet package — almost like you wouldn’t even know there was a container spun up! Let’s dive into it. Overview of C# Testcontainers Testcontainers is an awesome NuGet package that can greatly enhance your testing and local development workflow when building .NET applications. It provides a simple and effective way to manage Docker containers, allowing you to spin up lightweight and isolated instances and have them tear down like nothing ever happened! That means with Testcontainers, you no longer have to worry about setting up and tearing down test databases or dealing with complex configuration files. It handles all the details of container management, making this process feel trivial — I sure wouldn’t want to handle this manually. Some of the key benefits of Testcontainers include: Its ability to provide a consistent and reproducible test environment. You can define the exact service version and configuration that you require, ensuring that your test results are reliable and consistent across different environments. The speed and flexibility it brings to your testing and development workflow. By using lightweight Docker containers, you can quickly spin up and tear down test environments on demand. No configuring cloud or shared resources ahead of time… Just on-the-fly awesomeness. Seamless integration with existing testing frameworks and tools in the DotNet ecosystem, such as Xunit, NUnit, and BenchmarkDotNet. This allows you to easily incorporate containerized service instances into your existing test suites without any major modifications. For this article, we’ll be focusing on how we can use C# Testcontainers for MongoDB in particular. Much of the advice covered here will be applicable to other services, especially databases, but we’ll keep our sights set on MongoDB. Setting Up Testcontainers in C# To get started with Testcontainers in C#, you’ll need to install and configure the necessary dependencies in your project. Follow the steps below to set up Testcontainers for MongoDB in C#. 1. Installing Testcontainers Generally, the first step would be to install the Testcontainers NuGet package in your C# project. You would open the NuGet Package Manager Console, and run the following command: Install-Package Testcontainers However, we need the MongoDB flavor of this package (I am using version 3.8.0 at the time of writing) which includes the base Testcontainers package. You can install it via the package manager user interface or with this command: Install-Package Testcontainers.MonogoDB 2. Configuring Testcontainers for MongoDB Once you have installed Testcontainers, you need to configure it for MongoDB. This involves setting up a MongoDB container with the required settings. Here is an example of how you can configure Testcontainers for MongoDB in C#: using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .Build(); In the above example, we create a new instance of the , and specify the MongoDB image and port binding. The method sets the image for the MongoDB container, so using “mongo:latest” will always pull the latest image. MongoDbBuilder WithImage Optionally, we could use port binding to configure which ports we want to be using explicitly: using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .WithPortBinding(1337, 27017)
    .Build(); The code above uses method binds the container’s port 27017 to the host machine’s port 1337. We’ll see in the upcoming sections that unless you have a specific need to bind ports, you can potentially just leave this be. We can get a dynamic connection string, which is very convenient! WithPortBinding 3. Starting and Stopping the MongoDB Container After configuring Testcontainers for MongoDB, you can start and stop the container as needed. Here are code examples for starting and stopping the container: To start the MongoDB container: await container.StartAsync(); To stop the MongoDB container: await _container.StopAsync(); Remember the MongoDbContainer type can be disposed of, so call to clean up when you’re ready. DisposeAsync Using C# Testcontainers for MongoDB in Practice Now that we’ve seen how to spin up and tear down containers, what are we supposed to do with them? We have plenty of options, and truly, the limit is your own imagination (and time, money, and other resources…)! Most people leverage C# Testcontainers for writing integration or . You can match up Testcontainers with xUnit or NUnit, for example, and write tests that interact with a real database. functional tests For me, I needed to go wire C# Testcontainers for MongoDB up to BenchmarkDotNet so I could ! A similar use case where I needed transient local databases, but not necessarily for a test framework. benchmark inserting records into MongoDB Regardless, we need to be able to connect to these MongoDB database containers from C#, and these next subsections will cover that. Connecting to C# Testcontainers for MongoDB with MongoDB.Driver Let’s assume you read the earlier sections and you have the correct MongoDB package installed for Testcontainers. If you skimmed ahead to this section, go back, read it, and get the right package. Otherwise, you’ll be scratching your head about why you can’t find the right dependencies! You’ll also need to get the MongoDB.Driver NuGet package installed. This is what we’re going to be using to establish a connection to the database container that we spun up. I have other articles you can read if you want more explanation on how MongoDB.Driver works in general: MongoDB in C#: Simplified Guide For Inserting Data MongoDB Filtering in C# – Beginner’s Guide For Easy Filters How To Delete Documents From MongoDB In C# – What You Need To Know How To Update MongoDB Documents in C# – What You Need To Know With the right packages ready to go, we can combine the code we saw earlier with some MongoDB driver code to get things glued together: using MongoDB.Bson;
using MongoDB.Driver;

using Testcontainers.MongoDb;

MongoDbContainer container = new MongoDbBuilder()
    .WithImage("mongo:latest")
    .Build();
await container.StartAsync();
string connectionString = container.GetConnectionString();

MongoClient mongoClient = new MongoClient(connectionString);
IMongoDatabase database = mongoClient.GetDatabase("test");
IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("test"); In the example above, we can call on the newly spun-up MongoDB container from Testcontainers. The awesome part about this is that no matter how you configure your Testcontainer for MongoDB using the builder pattern we see in this code and earlier in the article, will get you what you need to connect. GetConnectionString() GetConnectionString() Because takes in a connection string as a single argument, it’s trivial to get access to the MongoDB database to start working with it right away! MongoClient Performing CRUD Operations on the MongoDB Testcontainer Now that we have our MongoDB Testcontainer set up and we have a connected to it, we can start performing CRUD operations on it. The connection details provided by the container instance made it a breeze to combine these two things, and truly, we can focus on just the MongoDB.Driver method calls for CRUD. MongoClient Here’s an example of performing a simple CRUD operation: // using code from earlier examples...

// Create
await collection.InsertOneAsync(new BsonDocument()
{
    ["Name"] = "Nick Cosentino",
});

// Read
var filterBuilder = Builders<BsonDocument>.Filter;
var filter = filterBuilder.Eq("Name", "Nick Cosentino");
var results = collection.Find(filter);

// Update
var updateBuilder = Builders<BsonDocument>.Update;
var update = updateBuilder.Set("Name", "Dev Leader");
collection.UpdateOne(filter, update);

// Delete
filter = filterBuilder.Eq("Name", "Dev Leader");
collection.DeleteOne(filter); Using the previous code snippets, we were already up and running with our MongoDB container instance and a . As a result, you can see in the code snippet above that we can directly work with our that we obtained from the prior setup. MongoClient IMongoCollection<BsonDocument> This helps illustrate that once you have the MongoDB docker container up and running via Testcontainers, you don’t have to treat things any special way once you connect to it! Wrapping Up C# Testcontainers for MongoDB To conclude, C# Testcontainers for MongoDB is an incredibly simple way to get a transient MongoDB data store up and running for your testing and development. While this article didn’t focus on specific use cases, hopefully, you have a better understanding of how transparent it feels to layer a MongoDB driver on top of Testcontainers to interact with MongoDB. Given that C# Testcontainers takes the headache out of the setup, teardown, and even connection string management, it’s an easy recommendation from me if you want to get up and running with MongoDB for local usage. If you found this useful and you’re looking for more learning opportunities, consider , and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here

Easily Run Local Databases Using C# Testcontainers for MongoDB

MongoDB-এর জন্য C# টেস্ট কনটেইনার ব্যবহার করে সহজেই স্থানীয় ডেটাবেস চালান

Führen Sie ganz einfach lokale Datenbanken mit C#-Testcontainern für MongoDB aus

Ejecute fácilmente bases de datos locales utilizando C# Testcontainers para MongoDB

Exécutez facilement des bases de données locales à l'aide de C# Testcontainers pour MongoDB

MongoDB के लिए C# टेस्टकंटेनर का उपयोग करके आसानी से स्थानीय डेटाबेस चलाएँ

MongoDB 用の C# Testcontainers を使用してローカル データベースを簡単に実行する

MongoDB용 C# 테스트 컨테이너를 사용하여 로컬 데이터베이스를 쉽게 실행

Execute facilmente bancos de dados locais usando C# Testcontainers para MongoDB

Легко запускайте локальные базы данных с помощью тестовых контейнеров C# для MongoDB

MongoDB için C# Testcontainer'larını Kullanarak Yerel Veritabanlarını Kolayca Çalıştırın

Dễ dàng chạy cơ sở dữ liệu cục bộ bằng C# Testcontainer cho MongoDB

使用 MongoDB 的 C# 测试容器轻松运行本地数据库

Easily Handle Faults And Retries With Polly In C#

Almost any web app that contains data needs a way to represent it succinctly and clearly to the user. However, most Python web development solutions do not provide an easy way to do this purely in . Python Thanks to the plethora of existing React components for creating graphs, an implementation for Python can be created to easily solve this problem. In this post, we’ll walk through how to build a web app purely in Python, which contains graphs that strike a balance between flexibility and ease of use. The graphs are easy to build but also easy to customize to your needs. For this project, we are going to use a new open-source dev tool called Reflex. 1. Getting started with your Python Web App If you face any problems here with installation check out more docs here: https://reflex.dev/docs/getting-started/installation/ $ pip install reflex $ reflex init 2. Creating an Interactive Graph In this example, we will create a live-streaming graph that updates every second with random data. We start by defining some initial data for our chart to use, as well as some imports we will use for the project: from typing import Any, Dict, List
import reflex as rx
import random
import asyncio

data = [
    {"name": "A", "uv": 10, "pv": 110, "amt": 210},
    {"name": "B", "uv": 20, "pv": 120, "amt": 230},
    {"name": "C", "uv": 30, "pv": 120, "amt": 240},
    {"name": "D", "uv": 30, "pv": 130, "amt": 210},
    {"name": "E", "uv": 20, "pv": 140, "amt": 230},
    {"name": "F", "uv": 40, "pv": 170, "amt": 250},
    {"name": "G", "uv": 50, "pv": 190, "amt": 260},
] Here stands for unique visitors, stands for page views and stands for amount. uv pv amt They are arbitrary values that we will use to populate our graph. Next, we define a class that will be used to store the data and update it with an event handler: StreamingState class StreamingState(rx.State):
    data: List[Dict[str, Any]] = data
    stream: bool = False

    def stop_stream(self):
        self.stream = False

    @rx.background
    async def start_stream(self):
        async with self:
            self.stream = True
        while self.stream:
            async with self:
                for i in range(len(self.data)):
                    self.data[i]["uv"] = random.randint(0, 100)
                    self.data[i]["pv"] = random.randint(100, 200)
                    self.data[i]["amt"] = random.randint(200, 300)
            await asyncio.sleep(3) Here, we define a method that will stop the stream when called. We also define a method that will start the stream. We use the decorator to run the method in the background. This allows us to update the data without blocking the UI. stop_stream start_stream @rx.background Remember to use when updating the state in a background task. async with self: Finally, we will define our UI using Reflex's new graphing components. We pass the data from our class to the component and reference the data key we want to use in component. We also add a button to start and stop the stream. StreamingState area_chart area The result is a live updating graph that looks like this: The code for this graph is below: def index():
   return rx.vstack(
     rx.recharts.area_chart(
        rx.recharts.area(
            data_key="pv",
            stroke="#82ca9d",
            fill="#82ca9d",
            type_="natural",
        ),
        rx.recharts.x_axis(
            data_key="name",
        ),
        rx.recharts.y_axis(),
        rx.recharts.legend(),
        data=StreamingState.data,
        width="100%",
        height=400,
    ),
    rx.hstack(
        rx.button(
            "Start Stream",
            on_click=StreamingState.start_stream,
            disabled=StreamingState.stream,
        ),
        rx.button(
            "Stop Stream",
            on_click=StreamingState.stop_stream,
        ),
        width="100%",
    ),
    width="100%",
)

# Add state and page to the app.
app = rx.App()
app.add_page(index)
app.compile() The last three lines define our app, add the graph component to the base route, and then compile our app. Now, we can run it with the terminal command. $ reflex run 3. Multiple Graphs We can add extra components to our chart to show the and data as well. We can also add a an component to show the data when we hover over the chart. area uv amt graphing_tooltip cartesian_grid Keep in mind the child coming first will be displayed in the back, so the order of the components matter. area The code for this graph is below: def index():
  return rx.vstack(
    rx.recharts.area_chart(
        rx.recharts.area(
            data_key="pv",
            fill="#48BB78",
            stroke="#48BB78",
            type_="natural",
        ),
        rx.recharts.area(
            data_key="uv",
            fill="#F56565",
            stroke="#F56565",
            type_="natural",
        ),
        rx.recharts.area(
            data_key="amt",
            fill="#4299E1",
            stroke="#4299E1",
            type_="natural",
        ),
        rx.recharts.x_axis(
            data_key="name",
        ),
        rx.recharts.y_axis(),
        data=StreamingState.data,
        width="90%",
        height=400,
    ),
    rx.hstack(
        rx.button(
            "Start Stream",
            on_click=StreamingState.start_stream,
            is_disabled=StreamingState.stream,
            width="100%",
            color_scheme="green",
        ),
        rx.button(
            "Stop Stream",
            on_click=StreamingState.stop_stream,
            is_disabled=StreamingState.stream == False,
            width="100%",
            color_scheme="red",

        ),
        width="100%",
    )
)

# Add state and page to the app.
app = rx.App()
app.add_page(index)
app.compile() 4. Conclusion So that’s it; in just a few lines of simple code, you’ve created your live streaming graphing web app in pure Python. If you want to learn more about this and how to build graphs with Python check out this . documentation If you have questions, please comment them below or message me on Twitter at or on . Share your app creations on social media and tag me, and I’ll be happy to provide feedback or help retweet! @tgotsman12 LinkedIn Disclaimer: I work as a Founding Engineer at Reflex, where I build the open-source framework.

Python Web Development with Reflex: Creating Dynamic Graphs Easily

How are you, hacker?
🪐 has got you covered with fresh content from our trending stories of the day! Set email preference . Want to know what's trending right now?: The Techbeat by HackerNoon here Turn GPT-4 Into Your Expert: Fine-Tuning Large Language Models Easily By [ 2 Min read ]
Boost AI Performance with Fine-Tuning @whatsai Read More. Crossentropy, Logloss, and Perplexity: Different Facets of Likelihood By [ 5 Min read ]
We explore the link between three popular loss functions: crossentropy, logloss and perplexity @artemborin Read More. Creating a Data Lakehouse using Apache Iceberg and MinIO By [ 12 Min read ]
The promise of Data Lakehouses is in their capabilities for structured and unstructured data, all in a centralized solution using Apache Iceberg and MinIO. @minio Read More. Unveiling the Hidden Web: the Top 10 Search Engines and Websites for Deeper Online Exploration By [ 6 Min read ]
Unlocking the hidden web's secrets: 10 search engines, safety, ethics, and exploration tips. @abrahamdahunsi Read More. ChatGPT Now Speaks, Listens, and Understands: All You Need to Know By [ 2 Min read ]
All you need to know about new ChatGPT feature - Voice assistant @sergey-baloyan Read More. 75% Of Companies Are Banning the Use of ChatGPT: What Happened? By [ 4 Min read ]
Explore the rising concerns over data leaks with ChatGPT. From potential risks around user data privacy to high-profile incidents involving tech giants. @georgedrennan Read More. The 8 Most Dangerous Cash App Scams (with Screenshots) By [ 7 Min read ]
If you're a Cash App user, here are the eight most dangerous scams to look out for. @marcusleary Read More. The Cheapskate’s Guide to Fine-Tuning LLaMA-2 and Running It on Your Laptop By [ 5 Min read ]
Everyone is GPU-poor these days So my mission is to fine-tune a LLaMA-2 model with only one GPU and run on my laptop @bruce-li Read More. Stop Using State for React Forms, There is a Much Better Way! By [ 7 Min read ]
Learn how to optimize the performance of react forms by replacing useState with the native feature of JavaScript. @nirmalkumar Read More. August Rollups Data Analysis: A Closer Look at Transaction Activity By [ 2 Min read ]
As the primary direction for Layer2 scaling, the Rollup track has seen frequent developments lately. @opside Read More. Five Free AI Tools for Programmers to 10X Their Productivity By [ 3 Min read ]
These five AI tools will make the lives of programmers and coders easy by increasing the speed and accuracy of their coding projects. @mirzaariquealam Read More. LiteLLM Configs: Reliably Call 100+ LLMs By [ 3 Min read ]
How Anthropic forced us to change our open-source library @krrish Read More. Building Mental Resilience: An Exploration of the Four Quarter Method By [ 9 Min read ]
The Four Quarter Method: A Framework for Mental Resilience @scottdclary Read More. Who Could Have Guessed LLMs are Great at Compressing Images and Audio: Reports From New Research By [ 3 Min read ]
Despite training on text, models compressed images 43% better than PNG, and audio nearly 2x better than MP3. @mikeyoung44 Read More. 6 Great AI Tools Lead Engineers Need Their Teams to Adopt By [ 6 Min read ]
This year, 30% of engineering leaders have figured out how to turn AI into a substantial competitive advantage. Have you? @alexomeyer Read More. Unlocking Structured JSON Data with LangChain and GPT: A Step-by-Step Tutorial By [ 8 Min read ]
Manipulating Structured Data (from PDFs) with the Model behind ChatGPT, LangChain, and Python for Powerful AI-driven Applications. @horosin Read More. ExpressWebJs adds support for Bunjs By [ 2 Min read ]
ExpressWebJs now provides support for BunJs, a fast all-in-one JavaScript runtime. @futurecode Read More. Model Quantization in Deep Neural Networks By [ 6 Min read ]
To get your AI models to work on laptops, mobiles and tiny devices quantization is essential @aibites Read More. Understanding Dynamic Programming So You Can Use It Effectively By [ 11 Min read ]
I’ll discuss Dynamic Programming (DP) and how to use previous computation experience effectively. I hope you will find it interesting. @indrivetech Read More. Importance of Web3 Marketing and Women in Web3: An Interview With Victoria Vaughan By [ 6 Min read ]
An interview with Victoria Vaughan, the co-founder of InCryptoLand and former CEO of Cointelegraph. 🧑‍💻 What happened in your world this week?It's been said that , , . Feeling stuck? We got you covered ⬇️⬇️⬇️ We hope you enjoy this worth of free reading material. Feel free to forward this email to a nerdy friend who'll love you for it.See you on Planet Internet! With love,
The Hacker Noon Team ✌️ @musharraf Read More. writing can help consolidate technical knowledge establish credibility and contribute to emerging community standards ANSWER THESE GREATEST INTERVIEW QUESTIONS OF ALL TIME

The TechBeat: Turn GPT-4 Into Your Expert: Fine-Tuning Large Language Models Easily (9/27/2023)

The Noonification: Turn GPT-4 Into Your Expert: Fine-Tuning Large Language Models Easily (9/20/2023)

In today's digital age, AI's capabilities seem limitless, don't they? Picture this: An AI that doesn't just perform general tasks but specializes in a specific domain, much like an expert in any field. Basically, your AI accountant, AI lawyer, or even AI doctor at a super low cost! What if I told you that turning a generalist AI into a specialist is not a distant dream but a reality you can achieve right now? Welcome to the world of fine-tuning Large Language Models. Today, we'll discuss this powerful technique to make them masters in any domain you desire. The only downside is that you still need some data, but much less than training a model from scratch! Fine-tuning is the magic wand that can transform a jack-of-all-trades AI model into a domain-specific maestro. Whether you want an AI to help with medical queries, navigate the world of finance, or even assist with customer support, fine-tuning is the answer. With the right techniques, these models can be adapted to provide specialized knowledge, ensuring that they're not just generalists but experts in the area you need. However, like all good things, there's a catch – and I've dived deep into this in today's video. For those eager to get their hands dirty and explore this phenomenon, I also run a little applied demo with a cool platform that offers a user-friendly way to jump right in. If you have ever wondered how to make the most out of large language models and mitigate biases and hallucination issues, fine-tuning is what you were looking for. Learn more in the video: https://youtu.be/7mOD9kgqRf0?embedable=true&transcript=true

Turn GPT-4 Into Your Expert: Fine-Tuning Large Language Models Easily

আপনার বিশেষজ্ঞ হিসাবে GPT-4 চালু করুন: সূক্ষ্ম-টিউনিং বড় ভাষার মডেল সহজে

Machen Sie GPT-4 zu Ihrem Experten: Einfache Feinabstimmung großer Sprachmodelle

Convierta GPT-4 en su experto: ajuste fácilmente modelos de lenguajes grandes

Faites de GPT-4 votre expert : ajustez facilement de grands modèles de langage

GPT-4 को अपने विशेषज्ञ में बदलें: बड़े भाषा मॉडल को आसानी से फाइन-ट्यूनिंग करें

GPT-4 をエキスパートに変える: 大規模な言語モデルを簡単に微調整する

GPT-4를 전문가로 전환: 대규모 언어 모델을 쉽게 미세 조정

Transforme o GPT-4 em seu especialista: ajuste fácil de modelos de linguagem grande

Превратите GPT-4 в своего эксперта: простая настройка больших языковых моделей

GPT-4'ü Uzmanınıza Dönüştürün: Büyük Dil Modellerine Kolayca İnce Ayar Yapma

Biến GPT-4 thành chuyên gia của bạn: Tinh chỉnh các mô hình ngôn ngữ lớn một cách dễ dàng

将 GPT-4 变成您的专家：轻松微调大型语言模型

When the atmosphere was calm, the low temperature was easily borne

Real Time Data Processing: Easily Processing 10 Million Messages With Golang, Kafka and MongoDB

In this blog, I will be sharing a script that allows you to easily select a column in a Google Sheets spreadsheet and copy it to another spreadsheet while ensuring that the values are aligned in the same rows. Whether you're a Google Apps Script Developer or just someone looking to streamline their workflow, this script will be a helpful tool for you. This is Nibesh Khadka. I am a freelance Google Apps Script Developer and Content Creator. Referencing Columns Before Copying Copying a column from one sheet to another can be challenging if we don't have a unique column as a reference to put the values in the correct column. We can use columns like ID, Email, or any other column that exists in both sheets as a reference. In this article, we'll create a spreadsheet with two sheets and use the "ID" column as a reference to copy the "Name" column from to . Sheet1 Sheet2 You can just download and use this sheet or create your own. You can either follow the steps or download the complete code from the git . repository Script Editor Now this is the bound script. So, open the spreadsheet you want to use for this project and open the script editor from there. HTML Form For this project, unlike in the one, we'll be using with HTML instead of UI prompts because we'll need multiple input boxes for this project. previous Custom Dialog Boxes Create a new file in your script editor. Then copy and paste the following codes HTML <!DOCTYPE html>
<html>
<head>
  <base target="_top">
  
</head>

<body>
  <form onsubmit="formSubmitHandler(event)">
    <h2>Source Sheet</h2>
    <label for="sourceSheet">Source Sheet Name:</label><br>
    <input type="text" id="sourceSheet" name="sourceSheet"><br>
    <label for="referenceColumn">Reference Column Name</label><br>
    <input type="text" id="referenceColumn" name="referenceColumn"><br>
    <label for="sourceColumn">Source Column To Copy From:</label><br>
    <input type="text" id="sourceColumn" name="sourceColumn"><br>
    <hr>
    <h2>Target Sheet</h2><br>
    <label for="targetSheet">Target Sheet Name:</label><br>
    <input type="text" id="targetSheet" name="targetSheet"><br>
    <label for="targetReferenceColumn">Reference Column Name</label><br>
    <input type="text" id="targetReferenceColumn" name="targetReferenceColumn"><br>
    <label for="targetColumn">Target Column To Copy To:*</label><br>
    <input type="text" id="targetColumn" name="targetColumn"><br>
    

    <input type="submit" value="Submit" />

  </form>

  <script>
    function formSubmitHandler(event) {

      const sourceSheet = event.target['sourceSheet'].value;
      const referenceColumn = event.target['referenceColumn'].value;
      const sourceColumn = event.target['sourceColumn'].value;
      const targetSheet = event.target['targetSheet'].value;
      const targetReferenceColumn = event.target['targetReferenceColumn'].value;
      const targetColumn = event.target['targetColumn'].value ?? "";
      const data = [sourceSheet, referenceColumn, sourceColumn, targetSheet, targetReferenceColumn, targetColumn];

      // call server side function
     google.script.run.withSuccessHandler(closeDialog).setTargetColumns(data);

      event.preventDefault();

    }

    function closeDialog() { google.script.host.close() }
  </script>
</body>
</html> There are two to notice here. script runners is used to link the function in the form in the front-end to the function in the backend(script) code during operation success, in this case, is the backend function we're using. withSuccessHandler() setTargetColumns() which is used to close the dialog box. We are using it with to call the backend and then close the dialog box. close() withSuccessHandler() When rendered the Form looks like this: Feel free to style the HTML Form to make it more beautiful. In this HTML form you'll have to provide six pieces of information: The name of the Source Worksheet. The name of the Reference Column in the source sheet. The name of the Source Column in the source sheet whose value is to be copied. The name of the Target Worksheet where the value is to be copied. The name of the Reference Column in the target sheet. The name of the Target Column in the target sheet, that will hold the copied value. Copy Column to Different Sheet Now let's write the script to copy the values from one column to another. function renderForm() {
  const html = HtmlService.createHtmlOutputFromFile('form')
    .setWidth(400)
    .setHeight(600);// play with dimension to fit your need
  SpreadsheetApp.getUi() 
    .showModalDialog(html, "Copy Column With Reference");
}

//["Sheet1", "ID", "Name", "Sheet2", "ID", "Name"]
function setTargetColumns(data) {
  try {
    const sourceSheetName = data[0];
    const referenceColumnName = data[1];
    const sourceColumnName = data[2];
    const targetSheetName = data[3];
    const targetReferenceColumnName = data[4];
    const targetColumnName = data[5];

    // get sheet and data
    const sheet = SpreadsheetApp.getActiveSpreadsheet();
    const sourceSheet = sheet.getSheetByName(sourceSheetName);

    const sourceSheetData = sourceSheet.getDataRange().getValues();
    const sourceSheetLastRow = sourceSheetData.length;
    const sourceSheetLastColumn = sourceSheetData[0].length;
    // get header column of source sheet
    const sourceSheetHeader = sourceSheet.getRange(1, 1, 1, sourceSheetLastColumn).getValues().flat();

    // find the index of the given column names
    const referenceColumnIndex = sourceSheetHeader.indexOf(referenceColumnName.trim());
    if (referenceColumnIndex === -1) throw "Reference Column Not Found";

    const sourceColumnIndex = sourceSheetHeader.indexOf(sourceColumnName.trim());
    if (sourceColumnIndex === -1) throw "Source Column Not Found"; // if the name is not found then throw error

    const sourceSheetData2 = [sourceSheet.getRange(2, referenceColumnIndex + 1, sourceSheetLastRow, 1).getValues().flat(), sourceSheet.getRange(2, sourceColumnIndex + 1, sourceSheetLastRow, 1).getValues().flat()]


    const targetSheet = sheet.getSheetByName(targetSheetName);
    const targetSheetData = targetSheet.getDataRange().getValues();
    const targetSheetLastRow = targetSheetData.length;


    const targetReferenceColumnIndex = sourceSheetHeader.indexOf(targetReferenceColumnName.trim());
    if (targetReferenceColumnIndex === -1) throw "Target Sheets Reference Column Not Found";

    const targetColumnIndex = sourceSheetHeader.indexOf(targetColumnName.trim());
    if (targetColumnIndex === -1) throw "Target Sheet's Target Column Not Found";

    const targetSheetRefData = targetSheet.getRange(2, targetReferenceColumnIndex + 1, targetSheetLastRow - 1, 1).getValues().flat();
    const targetSheetColData = targetSheet.getRange(2, targetColumnIndex + 1, targetSheetLastRow - 1, 1).getValues();


    for (let i = 0; i < sourceSheetData2[0].length; i++) {
      for (let j = 0; j < targetSheetRefData.length; j++) {
        if (targetSheetRefData[j] === sourceSheetData2[0][i]) {
          targetSheetColData[j] = [sourceSheetData2[1][i]];
          break;
        }
        continue;
      }
    }
    // set new values 
    targetSheet.getRange(2, targetColumnIndex + 1, targetSheetLastRow - 1, 1).setValues(targetSheetColData);

  } catch (e) {
    // alert error
    SpreadsheetApp.getUi().alert(`Error: ${e}`)
  }
}


/**
 * Menu creates menu UI in the document it's bound to.
 */
function createCustomMenu() {
  const menu = SpreadsheetApp.getUi().createMenu("Copy Columns");

  menu.addItem("Copy Column", "renderForm");
  menu.addToUi();
}


/**
 * OnOpen trigger that creates menu
 * @param {Dictionary} e
 */
function onOpen(e) {
  createCustomMenu();
}

/**
 * This script is for safely and accurately copying one column to 
 * another column in two sheets while properly aliging with other
 * rows.
 * It is created in such a way that it only works with bound script.
 *
 * Created by: Nibesh Khadka.
 * linkedin: https://www.linkedin.com/in/nibesh-khadka/
 * website: https://nibeshkhadka.com
 */ Now, similar to the , you can now just: previous blogs Save the code. Reload the spreadsheet. Where you'll see the custom menu as shown below And execute the function. After this, you'll see a menu like the image below in the spreadsheet. Error In case you leave any input box empty or you gave the wrong names to the boxes, you'll see the error alert like the image below. Thank You for Your Time My name is Nibesh Khadka, and as a freelance automation expert, I specialize in automating Google products with Apps Script. So let's get started! If you need my services let me . know Don’t forget to like and share this blog. Also published . here

How to Copy a Column From One Sheet to Another in Google Sheets Easily 

If you know , it’s easy to add the ability to create, mint, and manage non-fungible tokens (NFTs) to your app. The wraps REST calls to Ethereum nodes, abstracting away the technical compilations and making it possible to work with NFTs with just an Infura account, some configuration, and a few lines of code. The also doesn’t require the overhead of learning Solidity, importing ABIs, etc. Whether you are new to or highly experienced, Infura NFT SDK makes NFTs easy. typescript Infura NFT SDK Infura NFT SDK web3 Let’s jump in, build, and deploy an to see how it works. ERC721 NFT What is the Infura NFT SDK? The is an SDK that allows you to build and interact with NFTs easily.  It’s implemented in TypeScript, a programming language that is a strict superset of JavaScript. The SDK includes the ability to create, mint, and manage NFTs and query information about them. Infura NFT SDK The significant part is that it abstracts away the technical details so you can focus on the core functionality of your dApp instead of the (often difficult) details. It’s all about ease of use with Infura SDKs! Supported chains include: Write Ethereum: Mainnet, Goerli, Sepolia Polygon: Mainnet, Mumbai Read Ethereum: Mainnet, Goerli, Sepolia Polygon: Mainnet, Mumbai BSC: Mainnet By using the Infura NFT SDK, you also get access to Infura's core functionality and infrastructure, which provides access to Ethereum (and other blockchains) without requiring you to run a full node. With the SDK, you can leverage many capabilities, making it easier to build and scale your dApps. So let’s build an NFT and see what the SDK can do. Building and Deploying ERC721 NFT We will build a and on Ethereum and use the SDK to create a new NFT. We’ll do all this on the Ethereum Goerli testnet, so we don’t have to worry about defects or the cost of deploying to the mainnet. dApp smart contract Prerequisite Before getting started, you need the following prerequisites: and its package manager NPM. Verify you have Node.js installed by using the following terminal command: node -v && npm -v Node.js installed TypeScript An Infura account A basic understanding of TypeScript and JavaScript MetaMask Infura The Infura NFT SDK is really simple to use. In fact, most of this tutorial is just the setup and configuration needed to create a dApp. Let’s start by to your Infura account. You should be on your dashboard, where you can create a new key, as shown below. We’ll create a new key for this project. logging in Click the “Create a New Key” button and fill in the required information. After creating your key, your project ID will be visible on your dashboard under the API KEY section, as shown below. Copy and keep it somewhere; you’ll need it later in this tutorial. Set up IPFS project on Infura Dashboard Now, let’s create an project. is a P2P distributed file system for storing and accessing files (and other data). It works well with blockchain. We’ll need IPFS (and these credentials) to upload and store the metadata of our NFT project. IPFS IPFS Head to your dashboard and create another new key by clicking “Create a Key”, as shown below. This time we’ll choose IPFS as the network. This project will work on the mainnet and (what we will use it for) testnet. After creating your key, you’ll see your project ID and API key secret under the API KEY section of your dashboard. You’ll need this later as well, so copy it and keep it somewhere safe. Project Setup and Installation Next, we’ll set up and initialize a node.js Typescript project. Use the following commands in your console: mkdir typescript-nft-demo && cd typescript-nft-demo

npm init -y

npm install -D typescript ts-node

npx tsc --init Open the project in your preferred development environment. For example, if you are using Visual Studio Code, use the following command to open the project automatically: code . Install the Project Libraries Next, we need to install the Infura SDK and dotenv library for reading the environment variables. Use the following command: npm install @infura/sdk dotenv Your project should have something similar to what is shown below: Create a file at your project's root and add the following variables to it: .env INFURA_PROJECT_ID=<YOUR-INFURA-PROJECT-ID>

INFURA_PROJECT_SECRET=<YOUR-INFURA-PROJECT-API-KEY>

WALLET_PRIVATE_KEY=<YOUR-WALLET-MNEMONIC/PRIVATE-KEY>

EVM_RPC_URL=https://goerli.infura.io/v3/<YOUR-PROJECT-API-KEY>

INFURA_IPFS_PROJECT_ID=<YOUR-INFURA-IPFS-PROJECT-ID>

INFURA_IPFS_PROJECT_SECRET=<YOUR-INFURA-IPFS-PROJECT-SECRET-KEY>

WALLET_PUBLIC_ADDRESS=<YOUR-WALLET-ADDRESS> Replace and with the and key from the Infura project created earlier in this tutorial. <YOUR-INFURA-PROJECT-ID> <YOUR-INFURA-PROJECT-API-KEY> ID API Replace and with the and key from the project created earlier in this tutorial. <YOUR-INFURA-IPFS-PROJECT-ID> <YOUR-INFURA-IPFS-PROJECT-SECRET-KEY> ID API IPFS On the line starting with , replace with your . EVM_RPC_URL <YOUR-PROJECT-API-KEY> Infura API key should be replaced with your public blockchain address. <YOUR-WALLET-ADDRESS> is your wallet's private key. <YOUR-WALLET-MNEMONIC/PRIVATE-KEY> Note: Never share your private keys (mnemonic) with anyone, and keep them secure. You can find your wallet address and private key to your wallet on MetaMask in the following steps: Open MetaMask by clicking on the browser extension icon or visiting the MetaMask website. Click on the three dots in the top right corner of the MetaMask window. Select “Account Details” from the drop-down menu, and click on the “Export Private Key” button. A pop-up window will appear, asking you to enter your password. Enter your password and click on the “Unlock” button. Once your account is unlocked, you can see your private key. Remember: keep your and your private key with anyone else. Also, be sure you're connected to the Goerli testnet, not the mainnet, as shown in the image below. private key safe never share Now that we’ve successfully configured our project, create a new TypeScript file at the root level. nft.ts Your project structure should look similar to the one below. Setup Infura Authentication Authentication from inside our dApp requires our PROJECT_ID and PROJECT_SECRET. We’ll load these from our new .env file. Create an auth object inside the using the following code snippet: nft.ts import { config as loadEnv } from "dotenv";
import { SDK, Auth, Metadata, TEMPLATES } from "@infura/sdk";

// load environment variables from .env file
loadEnv();

// Create an instance of the Auth class 
const auth = new Auth({

  // set the projectId taken from the INFURA_PROJECT_ID environment variable 
  projectId: process.env.INFURA_PROJECT_ID,

  // set the secretId taken from the INFURA_PROJECT_SECRET environment variable 
  secretId: process.env.INFURA_PROJECT_SECRET,

  // set the private key taken from the WALLET_PRIVATE_KEY environment variable 
  privateKey: process.env.WALLET_PRIVATE_KEY,

  // set the rpcUrl taken from the EVM_RPC_URL environment variable 
  rpcUrl: process.env.EVM_RPC_URL,

  // set the chainId for the Goerli testnet
  chainId: 5, // Goerli

  // set the options for IPFS
  ipfs: {

    // set the project Id taken from the INFURA_IPFS_PROJECT_ID environment variable
    projectId: process.env.INFURA_IPFS_PROJECT_ID,

    // set the API key secret taken from the INFURA_IPFS_PROJECT_SECRET environment variable
    apiKeySecret: process.env.INFURA_IPFS_PROJECT_SECRET,
  },
});

// Instantiate the SDK
const sdk = new SDK(auth); Configure the file as shown. (You might get an error but keep going.) is a configuration file for TypeScript projects. It’s used to specify the compiler options and files that should be included in the project. tsconfig.json tsconfig.json Configure your with the following code snippet: tsconfig.json {
        "compilerOptions": {

          "target": "ESNext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */

          "module": "ES2022", /* Specify what module code is generated. */

          // "rootDir": "./",                                  /* Specify the root folder within your source files. */

          "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */

          "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */

          "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */

          /* Type Checking */

          "strict": true, /* Enable all strict type-checking options. */

          "skipLibCheck": true /* Skip type checking all .d.ts files. */
      }
} Next, add the module to the file using the following code snippet: type package.json //...

"type": "module",
"scripts": {},

//... Create Token Metadata Now we’re done configuring. Let’s get to the exciting stuff! First, we’ll create the token metadata. Token metadata refers to additional information or data associated with a token (typically an ERC-721 or ERC-1155 token on the Ethereum blockchain). This metadata can include information such as the token's name, symbol, image, and other attributes that describe the token or give it context. The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata. Inside the , add the following code snippet. It will create and store the token metadata. The metadata class is from the Infura NFT SDK. nft.ts file (Note: The external_url is just for demo purposes here and can be replaced.) consensys.net // Define the properties of the token, including its description, external URL, image, name, and attributes
const tokenMetadata = Metadata.openSeaTokenLevelStandard({

  description: "Fantastic creature of different emojis",

  external_url: "https://consensys.net/",

  image: await sdk.storeFile({

    // Store the image from the given URL
    metadata: "https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg",

  }),
  name: "Kandy Jane",
  attributes: [],
});

// Log the token metadata object to the console
console.log("Token Metadata: ", tokenMetadata);


// Store the token metadata and log the result
const storeTokenMetadata = await sdk.storeMetadata({ metadata: tokenMetadata });

console.log("Store Token Metadata: ", storeTokenMetadata); Create the Contract Metadata Contract metadata refers to additional information or data associated with a smart contract on a blockchain network. This metadata can include information such as the contract's name, symbol, version, and other attributes that describe the contract or give it context. The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata. Create contract metadata using the following code snippet: //...

// Define the properties of the collection, including its description, external URL, image, name, and attributes
const collectionMetadata = Metadata.openSeaCollectionLevelStandard({

  name: "Emojis collection", // Sets the name of the collection to "Emojis collection"

  description:
    "A small digital image or icon used to express an idea or emotion in electronic communication. Emoji's come in many forms, such as smiley faces, animals, food, and activities. ", // Sets the description of the collection
  image: await sdk.storeFile({

    // Sets the image property of the collection using the storeFile method
    metadata:
"https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg", // The URL of the image file
  }),

  external_link: "https://google.com/", // Sets the external link property of the collection
});

// Logs the collection metadata to the console
console.log("Collection Metadata:- ", collectionMetadata); 

// stores the metadata using the storeMetadata method
const storeMetadata = await sdk.storeMetadata({ metadata: collectionMetadata }); 

// Logs the store metadata to the console
console.log("Store Metadata: ", storeMetadata); This code snippet above creates an object using the method from the Metadata class. The method creates standard collection-level metadata compatible with , a leading marketplace for NFTs. It sets the collection's name, description, image, and external link properties; stores the metadata using the method; then logs it and stores it in the console for . collectionMetadata openSeaCollectionLevelStandard openSeaCollectionLevelStandard OpenSea storeMetadata debugging Create a New Contract and Mint an NFT Add the following code to create a new contract and mint an NFT using the Infura NFT SDK. Most of this functionality comes to us from our new NFT SDK! //...

// Create a new contract
const newContract = await sdk.deploy({   // deploys a new contract using the sdk.deploy method

  template: TEMPLATES.ERC721Mintable,     // sets the template for the contract to ERC721Mintable
  params: {
    name: "1507Contract",                  // sets the name of the contract as "1507Contract"
    symbol: "EMOJI",                        // sets the symbol of the contract as "EMOJI"
    contractURI: storeMetadata,             // sets the contract URI with the storeMetadata
  },
});

console.log("Contract Address: \n", newContract.contractAddress);  // logs the contract address to the console

// mint an NFT
const mint = await newContract.mint({  // mints a new NFT using the mint method from the new contract

  publicAddress:
    process.env.WALLET_PUBLIC_ADDRESS ??

    "0x510e5EA32386B7C48C4DEEAC80e86859b5e2416C", // sets the public address of the wallet, if not set it will use the given address

  tokenURI: storeTokenMetadata,                // sets the token URI with the storeTokenMetadata

});

const minted = await mint.wait();            // waits for the minting process to complete

console.log("Minted: ", minted);               // logs the minted NFT to the console This code creates a new contract using the method and sets the template for the contract to . Then it sets the contract's name, symbol, and contract URI. The contract address is logged for debugging. sdk.deploy ERC721Mintable It then mints a new NFT using the method from the new contract and sets the wallet's public address. If not specified, it uses the given address and then sets the token URI with the . mint storeTokenMetadata Finally, it waits for the minting process to complete and logs the minted NFT to the console. Let’s test it out! ts-node-esm nft.ts You should see something similar to what is shown below: Verify Contract on Account and Goerli Etherscan Finally, let’s verify the contract using a blockchain explorer on the . Go to the and paste the transaction hash from your output above (as shown below). Goerli Etherscan Goerli Ethereum testnet site You should see the details. That was easy! We successfully utilized the Infura NFT SDK to build, deploy, and mint an NFT on the Goerli testnet. Import token on MetaMask Let’s look at our new NFT from a front-end perspective using MetaMask. First, we have to import our wallet to MetaMask. Click “Import Tokens”, as shown in MetaMask. (Be sure you are connected to the Goerli Testnet as shown.) Copy and paste the contract address to import your token on MetaMask, as shown below. And there it is! An easy and fast way to add NFTs to your dApps. You can use the SDK now to manage the NFTs and more ( ). see the docs for current capabilities Verify Minted NFT on OpenSea We’ve successfully imported the minted NFT on MetaMask, but now let’s verify on . Connect your wallet and view your new NFT. You should have something similar to what is shown below. OpenSea tesnet For reference, to the NFT created. You can find the complete code on a GitHub repository . here’s the OpenSea link here Conclusion In conclusion, the new Infura NFT SDK for TypeScript is a powerful tool for developers looking to incorporate NFTs into their dApps. With its easy-to-use functions and comprehensive features, this SDK makes it simple to deploy, mint, and manage NFTs on the Ethereum blockchain. ! Sign up and start building I'd love to connect with you on | | | Twitter LinkedIn GitHub Portfolio See you in my next blog article. Take care!!! Also published . here

Stories, News & Mentions about EASIL

Easil’s Stories on HackerNoon

Easil's News & Mentions