DEV Community: Sarah Schlueter

Resolving API Records Limit Issue with Pagination

Sarah Schlueter — Thu, 23 Jan 2025 15:07:11 +0000

For a bit of context, Kronos is a workforce management software use to help employers manage their employees, time and attendance, scheduling and payroll. This post isn't necessarily supposed to be a tutorial, but I wanted to document the experience with this since it was helpful to me, it may be helpful to someone else. Please feel free to comment if you have questions or would like further clarification or context on something.

I was writing a program that would pull records from saved reports using their report IDs from Kronos. It was known that the API call had a limit of 100,000 records so the reports were saved in a way that they had under 100k records.

This was fine until all of the sudden, I'm calling the API to get reports data in order to insert into a SQL database, and the result set is only 50,000 records when previously it was around 60-70k records.

After checking the documentation, I realized I could resolve this issue using pagination. Here's how I tested and resolved the issue...

Set up and Testing in Postman

I created a collection in Postman titled 'Kronos Reports' and set up my requests. The first POST request for logging in to the tenant and retrieving the token, setting it as an environment variable to use in the next POST request for retrieving the saved reports. The APIs used:

{{baseurl}}/ta/rest/v1/login
{{baseurl}}/ta/rest/v1/report/saved/{{reportID}}

I initially had started out using their GET request for the reports, however, in order to apply pagination you need to use a post request and put the following json in the response body:

{
    "page": {
        "number": 0,
        "size": 50000
    }
}

Page number needs to start at 0, and will return the first 50000 records (or whichever amount you choose). I set it at 50,000 since that seemed to be the cap after throttling.

Once I set my relevant headers, I created a Post-response script to write the record counts to the console:

const xml2js = require('xml2js');
let jsonResponse;
xml2js.parseString(pm.response.text(),{explicitArray: false}, (err, result)=>{

    jsonResponse = result;

});
const rows = jsonResponse.result.body.row;
const rowCount = Array.isArray(rows) ? rows.length : (rows ? 1 : 0);
console.log("Number of rows:", rowCount);

Then I could call the API and see that for page 0, records returned were 50000, set the page to 1 and ran again which showed the records returned were 18927. Perfect, we're done.

Implementing in the code

My project is a .NET 8.0 Console App written in C# and using the latest version of RestSharp (version 111.4.1 at the time of this writing).

I adjusted my API call to use Method.Post, and wrapped it in a while loop. I set a bool variable hasMorePages initially to true, and created variables for the page number and page size, initially set to 0 and 50000, respectively.

RestSharp has an AddJsonBody() method in which I used to insert the pagination json code to the request body:

request3.AddJsonBody(new
{
    page = new
    {
        number = pageNumber,
        size = pageSize
    }
});

I also created another variable List<row> allRecords to add the results to. The code loops through as long as hasMorePages is true. If the results count is less than the page size, hasMorePages is assigned to false and exits the loop. Otherwise, the pageNumber is incremented by 1.

Adding Records from Multiple Reports to be added to Database together

Since we have the 100,000 record limit on pulling saved reports data, this resulted in splitting our report into 3 parts. Since we will run this daily to update the data, we want to combine all of the reports in the code so that we only need to run it and insert into the database once.

For this I just wrapped my API call in the while loop in a foreach loop that loops through a list of the reportIDs, passing the temporary reportId variable in the RestRequest.

Here is the final API call code:

var options = new RestClientOptions(strBaseURL)
{
    ConfigureMessageHandler = handler =>
    {
        var httpClientHandler = (HttpClientHandler)handler;
        httpClientHandler.CookieContainer = new CookieContainer();
        httpClientHandler.UseCookies = true;
        return httpClientHandler;
    },
    Timeout = Timeout.InfiniteTimeSpan,
    UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36"
};

var client = new RestClient(options);
var request2 = new RestRequest("/ta/rest/v1/login", Method.Post);
request2.AddHeader("Api-Key", strAPIKey);
request2.AddHeader("Accept", "application/json");
request2.AddParameter("application/json", JsonConvert.SerializeObject(me), ParameterType.RequestBody);
var response2 = await client.ExecuteAsync(request2);
Kronos_Login_ResponseBody responsebody = JsonConvert.DeserializeObject<Kronos_Login_ResponseBody>(response2.Content);

string strToken = responsebody.token;

bool hasMorePages = true;
int pageNumber = 0;
int pageSize = 50000;

var options2 = new RestClientOptions(strBaseURL)
{
    ConfigureMessageHandler = handler =>
    {
        var httpClientHandler = (HttpClientHandler)handler;
        httpClientHandler.CookieContainer = new CookieContainer();
        httpClientHandler.UseCookies = true;
        return httpClientHandler;
    },
    Timeout = Timeout.InfiniteTimeSpan,
};

var client2 = new RestClient(options2);
List<Row> allRecords = new List<Row>();

// just example report numbers
List<string> reportIds = new List<string> { "123456789", "987654321", "456478415" };

foreach (string reportId in reportIds)
{
    while (hasMorePages)
    {
        var request3 = new RestRequest($"/ta/rest/v1/report/saved/{reportId}", Method.Post);
        request3.AddHeader("Authentication", "Bearer " + strToken);
        request3.AddHeader("Accept", "application/xml");
        request3.AddHeader("company", strCompanySysID);
        request3.AddHeader("Content-Type", "application/json");

        request3.AddJsonBody(new
        {
            page = new
            {
                number = pageNumber,
                size = pageSize
            }
        });

        var response3 = await client2.ExecuteAsync(request3);

        XmlDocument doc = new XmlDocument();
        doc.LoadXml(response3.Content);

        string KronosXMLResponse = JsonConvert.SerializeXmlNode(doc);
        Root KronosEmployeeHoursReport = JsonConvert.DeserializeObject<Root>(KronosXMLResponse);

        allRecords.AddRange(KronosEmployeeHoursReport.result.body.row);

        if (KronosEmployeeHoursReport.result.body.row.Count < pageSize)
        {
            hasMorePages = false;
        }
        else
        {
            pageNumber++;
        }
    }

    hasMorePages = true;
}

Further, you want to add ordering by fields to the body so that each page doesn't produce duplicates. You can get the field names by calling the GET request with the additional /metadata on the end after the report id to include in the body of the post request. Here I used the employeeID and date:

{
    "page": {
        "number": 0,
        "size": 50000
    },
    "fields": [
        "EmplEmployeeId",
        "CalendarDate"
    ],
    "orders": [
        {
            "field_name": "EmplEmployeeId",
            "is_descending": false
        },
        {
            "field_name": "CalendarDate",
            "is_descending": false
        }
    ]
}

C# code:

request4.AddJsonBody(new
{
    page = new
    {
        number = pageNumber,
        size = pageSize
    },
    orders = new[]
    {
        new
        {
            field_name = "EmplEmployeeId",
            is_descending = false
        },
        new
        {
            field_name = "CalendarDate",
            is_descending = false
        }
    }
});

Resources:
https://secure2.saashr.com/ta/docs/rest/public/?r=v1report_saved_(settings_id)
https://restsharp.dev/docs/usage/request/#json-body
https://community.postman.com/t/occational-warning-that-xml2json-is-deptrecated/59745/5

Integrating Azure Secrets into your .NET Web Application

Sarah Schlueter — Fri, 26 Jan 2024 03:41:46 +0000

I recently was tasked with building a boilerplate application to serve as a starting point for new applications for the University of Wisconsin - Superior. Since working with the application development team, I've learned so much about development in C# and using the .NET framework, as well as getting to work more with Microsoft Azure.

I plan to write more tutorials as I progress and learn more, but I wanted to quickly share this info since I really struggled with it, and I did not find any helpful resources online that were straightforward.

The application referenced in this tutorial is an ASP.NET Web Forms Application (.NET Framework).

What you’ll need:

Key vault created in Azure
Vault URI (https://<your-key-vault-name>.vault.azure.net/)
The connection string for your database added as a secret in your key vault
Name of the Secret that stores your connection string

Prerequisites:

Ensure you are logged into Visual Studio with the same user account that is used for the database connection.
Ensure there are no other database connections active (i.e. under connected services, etc.)
Install the following packages:
- Azure.Core
- Azure.Identity
- Azure.Security.KeyVault.Keys
- Azure.Security.KeyVault.Secrets

Depending on your individual project needs you may need other packages installed as well, but these are the ones required to integrate Azure Key Vault.

Add your Azure Key Vault URI in Web.config file

In the web.config file under <appSettings> you’ll need to add the following code:

<add key="KeyVaultUrl" value="<https://your-keyvault-name.vault.azure.net/>" />

Feel free to change the key to whatever you like, and replace the value with your specific Key Vault URI.

You do have the option to skip this step and just use the URI in your code each time, but I find this is less hassle to save it here and just use the key in the rest of your code where you need it.

Using your secret in the code:

In the boilerplate code, you can see two examples of secret integration in the Contact.aspx.cs file. These are implemented in the btnSend_Click() and btnRetrieve_Click() methods.

In this case, the key value in <appSettings> is the same as the variable name created here.

Example code:

Step 1. In your method, create a variable of type string to store your key vault URI:

string KeyVaultUrl = ConfigurationManager.AppSettings["<your-appsettings-key-name>"];

Step 2. Create another variable of type string to store the name of your secret containing the connection string:

string secretName = "<your-secret-name>";

Step 3. Create a new SecretClient that takes your Key Vault URI and a new DefaultAzureCredential() as parameters. For the new URI() enter your KeyVaultUrl variable from step 1. Create a variable of type KeyVaultSecret and assign to your SecretClient calling GetSecret() on your secretName from step 2.

Step 4. Finally, create a variable of type string to store your connection string by grabbing the value of your KeyVaultSecret from step 3.

That's it! The rest of the code would be tailored to your specific project needs.

Thank you for reading! Hope this was helpful. Please feel free to leave any feedback or questions in the comments.

Connect with me:
Twitter: @sarah_schlueter

Discord: sarahmariedev

Getting Started with Pandas Library

Sarah Schlueter — Wed, 10 Jan 2024 16:59:17 +0000

I recently completed the US States Game project from the Python Pro Bootcamp course on Udemy in which we used the Pandas library to read and use data from a .csv file in order to create the functionality of the game.

Since there is a lot you can do with Pandas, I wanted to dive into a few of the things I learned about it and solidify the concepts I learned. I also want to make note that Pandas has really great documentation and I encourage you to check it out: https://pandas.pydata.org/docs

Installing & Importing Pandas into Your Project

Installing and importing Pandas is easy. For this post, I will be working in PyCharm.

MacOS:

Windows:

Start by importing Pandas into your project by writing the following ling of code at the top of your file:

import pandas

In PyCharm, you may see some red squiggly lines underlining pandas which means Pandas package needs to be installed. On MacOS you can just click the red light bulb that pops up when you hover over it and select ‘Install package pandas’. On Windows you can install the package by opening the ‘Python Packages’ window, searching for Pandas, and installing the current stable version (this can be found in the docs). At the time of this writing, the current version is 2.1.4.

Mac OS:

Windows:

💡 Note: We can also implement import pandas as pd so that we can write the shorthand pd in our code instead of writing out pandas when using it.

Handling Import Errors

I did not come across any errors using Pandas in PyCharm, but I opened my project in VS Code and came across errors later when running the program. This was because I was using a different interpreter from the system in VS Code vs. a virtual environment. It is recommended to use Pandas from a virtual environment (venv) rather than a system environment. I won’t go into great detail here, but you’ll just want to make sure you’re Python interpreter is set up in a virtual environment, as recommended in the documentation.

Basic Operations

Creating a DataFrame

Pandas uses a data structure called a DataFrame which is a two-dimensional structure that can be thought of as like a dictionary. You can create a DataFrame manually or from a .csv file.

To create a DataFrame manually, we can start by creating a dictionary of data:

user_list = {
    "first name": ["Scott", "Kevin", "Johnny"],
    "last name": ["Woodruff", "Bong", "Cosmic"],
    "email address": ["scott@example.com", "kevin@example.com", "johnny@example.com"],
    "user id": [123, 234, 345]
}

Then we will create a variable called user_data and call pandas.DataFrame on our user_list.

After that, we can call the to_csv() method on our user_data DataFrame object and pass in the name of the file we want to create:

user_data = pandas.DataFrame(user_list)
user_data.to_csv("user_data.csv")

After we hit run, we can see that there exists now a .csv file called user_data in the same directory as our main.py file. Opening it up, we can see our key names are the column names and each row is indexed. All of the values are separated by commas as .csv stands for Comma Separated Values.

We can also open it up in a spreadsheet and see the values there as well:

Let’s say we already have a .csv file of data that we want to use. To start working with that data in your project, you can place the .csv file into your project folder, and then use the read_csv() method. Here, I have a sample dataset of housing info I grabbed from PyDataset that I created a .csv file from just to show:

💡 Note: you can access sample datasets with PyDataset by adding from pydataset import data to the top of your file and choosing the data you want to work with. You can find more info on how to do this here. It’s pretty easy.

To start working with our data, we need to call the read_csv method on our dataset and save it into a variable:

data = pandas.read_csv("housing_data.csv")

You’ll want to make sure that the spelling and file path matches the file exactly otherwise you’ll get an error.

Now that we have our housing data in a variable, we can work with it. You’ll notice if you print data you can see the output shows a nice table with the column names and values.

You can confirm that we’ve created a DataFrame by checking the type of data and see the output in the console says it’s a pandas.core.frame.DataFrame:

Accessing Data by Column or Row

Each column in a DataFrame is called a Series and there are loads of different things you can do with them. There is a whole section in the docs dedicated to Series here.

Pandas automatically turns column names into attributes, so we can access a whole column using dot notation after our dataframe variable name. In our case, if we want to get only the column of prices, we can write:

print(data.price)

This will return just the items in the price column:

To access just a particular row of data, we’ll use brackets after our variable, then specify the column as before using dot notation and set it equal to the row value for which we want all related data. For example:

print(data[data.price == 38500.0])

This will return:

You can see the row of data here where the price column equals 38500.0 as indicated in the code.

Filtering and manipulating data

Now that we know how to obtain specific columns and rows, let’s use that to filter our data. Let’s say we want to find the lowest and highest home prices in this list. We can use the min() and max() methods for this.

print(data.price.max())
print(data.price.min())

OUTPUT:
190000.0
25000.0

Now say we are looking for a house and would like to have a list of only the homes that fit our budget and criteria. Let’s create a list that only contains homes that are under $50,000 and have at least 2 bedrooms and 1 bathroom.

Step 1: set the criteria as variables

max_price = 50000.0
num_bedrooms = 2
num_bathrooms = 1

Step 2: Apply the filters

filtered_data = data[(data['price'] < max_price) &
                     (data['bedrooms'] == num_bedrooms) &
                     (data['bathrms'] == num_bathrooms)]

Step 3: Create new .csv file with the filtered values

filtered_data.to_csv("our_home_choices.csv")

Our new file will appear in our project folder. We can open it to see that it includes only homes that are under $50,000 and have 2 bedrooms and 1 bathroom:

We can also check to see how many records there are in our new list by running the following line of code:

print(len(filtered_data))

In this case, it returns 61. So we can see that we have 61 homes to choose from with the criteria that we set. This can be further filtered down with the same method using the other columns as attributes.

Some Other Useful Methods

to_dict() Method

The to_dict() method is used to convert a DataFrame into a dictionary. This can be particularly useful when you need to transform your data for a format that is more compatible with certain types of processing. The method offers various formats for the dictionary, like orienting by rows, columns, or even index.

Example:

# Converting the entire DataFrame to a dictionary
data_dict = data.to_dict()

# Converting the DataFrame to a dictionary with a specific orientation
data_dict_oriented = data.to_dict(orient='records')  # Each row becomes a dictionary

to_list() Method

The to_list() method is used with Pandas Series objects to convert the values of the Series into a list. This is particularly useful when you need to extract the data from a DataFrame column for use in a context where a list is more appropriate, such as in loops, certain calculations, or data visualizations.

Example:

# Converting a DataFrame column to a list
price_list = data['price'].to_list()

# Using the list for further operations
average_price = sum(price_list) / len(price_list)

Both of these methods, to_dict() and to_list(), are part of Pandas' powerful suite of tools that make data manipulation and conversion simple and efficient, allowing for a smooth workflow between different data formats and structures.

Conclusion

I hope you enjoyed learning a bit about some of the things you can do with the Python Pandas library. This is just the tip of the iceberg, as there are many more capabilities to explore. I am excited to continue learning and sharing with you. I also encourage you to explore the documentation and experiment with your own datasets!

If you have any questions or if there's anything else you'd like to know about Pandas, please don't hesitate to reach out. I'll do my best to write a post about it. Writing also helps me learn more! 😊

Thanks for reading and happy coding!

Connect with me:
Twitter: @sarah_schlueter
Discord: sarahmarie73

Getting Started | Web Enumeration | Quick Solve

Sarah Schlueter — Mon, 25 Dec 2023 22:00:54 +0000

Today's post is going to be a walkthrough of the steps I took to find the flag for the challenge question in the Web Enumeration section of the Getting Started module on Hack The Box Academy.

You can also watch the walkthrough here:

Quick Overview

This section talks about file/directory & DNS enumeration using tools such as ffuf or GoBuster, and provides some helpful tips for web enumeration. It dives into different sources and tools that can be used to find helpful information about a target. I encourage you to read through the module and attempt the challenge on your own first.

The Task and Target

Try running some of the web enumeration techniques you learned in this section on the server above, and use the info you get to get the flag.

Target: 94.237.56.188:34678 (I save this right away to my notes for this lab)

Hack The Box Academy gives you an instance of their virtual machine in order to do these questions. I prefer to use my own Kali Linux virtual machine, so I'll be using that during this walkthrough.

My approach to these tasks since I'm still very new is to basically try everything and see what happens. Since all of my efforts don't always lead to anything of use, I won't include those steps in this post. I do, however, keep extensive notes on everything I do. That way, if I come across something similar in the future, I can reference back to what I did. Also, since this is more just a walkthrough, I'll let you refer to the module for more information on the specifics of the commands and such.

Anyway, let's dive in! 😊

The Walkthrough

In lieu of using the provided Pwnbox which uses an instance of Parrot Linux, I will use my own Kali Linux virtual machine. Since I am using Parallels, my machine is setup with a default user that I log in with. To make things easier, I want to switch to the root user. To do this, I just run the command sudo su and enter my password.

Now that I'm the root user, I want to cd into / (Root directory) and run a scan on the target using GoBuster and the dirb common.txt wordlist.

gobuster dir -u http://94.237.56.188:34678 -w /usr/share/dirb/wordlists/common.txt

This can take several minutes, but once it's done you should have an output that looks similar to this:

I save the output to my notes, since it's easier to reference back to than scrolling back up in the command line.

Checking out the results of the output, we can see that there is a /robots.txt file with an HTTP status code of 200, which is a standard response for successful HTTP requests. You can find a handy cheat sheet of HTTP status codes here.

Let's next navigate to the target url in the browser, and append the /robots.txt to the end to see what we can come up with there.

Here, we can see that the robots.txt file contains one disallowed entry. Navigating to http://94.237.56.188:34678/admin-login-page.php in the browser brings us to an Admin Panel login page.

Let's take a look at the source code. You can either right-click and choose "Inspect" to open developer tools, or hit CTRL + U on your keyboard.

Inspecting the code, I can see a comment at the bottom that contains some test credentials.

I go back to the login page and enter the credentials, which brings us to the flag to submit and complete the challenge. 😊

I hope you enjoyed this walkthrough and found it helpful. Thanks for reading!

Connect with me:
Twitter: @sarah_schlueter
Discord: sarahmarie73

Abstract Classes in Python

Sarah Schlueter — Wed, 20 Dec 2023 05:55:27 +0000

Hey everyone! I've been working on HackerRank's coding challenges and decided to start documenting what I learn so that I can learn it on a deeper level and also maybe help anyone else out there also learning.

Today I am working on HackerRank's 30 Days of Code Challenges - Day 13: Abstract Classes.(https://www.hackerrank.com/challenges/30-abstract-classes)

I've been working a lot in C# for school lately, but I was previously learning Python over the summer, so I will do this challenge in Python3 as a refresher.

The task is as follows:

Given a Book class, write a MyBook class that does the following:

Inherits from Book
Has a parameterized constructor taking these 3 parameters:
1. string title
2. string author
3. int price
Implements the Book class' abstract display() method so it prints these 3 lines:
1. Title:, a space, and then the current instance's title.
2. Author:, a space, and then the current instance's author.
3. Price:, a space, and then the current instance's price.

The following starter code is provided:

from abc import ABCMeta, abstractmethod
class Book(object, metaclass=ABCMeta):
    def __init__(self,title,author):
        self.title=title
        self.author=author

    @abstractmethod
    def display(): pass

#Write MyBook class

title=input()
author=input()
price=int(input())
new_novel=MyBook(title,author,price)
new_novel.display()

The first thing I do is check out the starter code to get a feel for what it's doing. We can see the first line of code imports tools from Python's abc module to create abstract base classes. Abstract base classes serve as blueprints for other classes, enforcing the implementation of specific methods in all subclasses that inherit from them.

The next line defines Book as an abstract base class using ABCMeta. The object indicates that Book is a new-style class inheriting from the base object class in Python.

The line def __init__(self, title, author) is the constructor method for the class. It is automatically called when a new instance of Book is created, initializing the title and author attributes of the instance.

Finally, @abstractmethod indicates that the display method is an abstract method. This means that any subclass of Book must provide its own implementation of the display method. The pass keyword is used as a placeholder indicating where code will eventually go. If a subclass does not implement this method, it cannot be instantiated (you can't create objects of that subclass).

You can read more on abstract methods and the abc module at https://docs.python.org/3/library/abc.html.

The code below where we will write the MyBook class sets the variables for title, author, and price to whatever input is provided by the user, with price being cast from a string to an integer. It instantiates an instance of MyBook called new_novel and calls the display() method.

So our first task is to create the MyBook class to inherit from the Book class. To do this, we just need to define the class and add the parent class as a parameter and add the __init__() function, which will override the parent class's __init__() function (more on this a bit):

def MyBook(Book):
    def __init__(self, title, author):

Since we want our MyBook class to have all of the properties and methods that are in the Book class we'll use the super() function. Then we'll add in the price property, which will be specific only to our subclass. Don't forget to add it to the __init__() function as a parameter as well:

def MyBook(Book):
    def __init__(self, title, author, price):
        super().__init__(title, author):
        self.price = price

The next step is to implement the Book class' abstract display() method. The challenge gives us the following output format:

Title: $title
Author: $author
Price: $price

Noting that the $ is prepended to variable names to indicate they are placeholders for variables.

I write the method as follows, using f-strings to produce the required output:

def display(title, author, price):
    print(f"Title: {title}")
    print(f"Author: {author}")
    print(f"Price: {price}")

Here I'm thinking I'm all set, so I run the code and get the following error:

- Traceback (most recent call last):

-   File "/tmp/submission/20231220/03/29/hackerrank-ff98319665ac0ee953b1fb5664e87cb3/code/Solution.py", line 27, in <module>
-     new_novel.display()
- TypeError: MyBook.display() missing 2 required positional arguments: 'author' and 'price'

Personally, I like to debug and step through code to see where I went wrong so I'm going to paste the code into my Thonny IDE. I like Thonny for small code challenges like this because it doesn't require setting up a whole project just to run and step through code.

After stepping through the code, I can see exactly where and what the issue is:

I realize that I could also get this information from the error message itself, but in my experience, just stepping through and seeing what everything is doing at a granular level helps me figure out the problem more easily.

The message says that I'm missing two required positional arguments. Time to do some digging at this point since I'm not sure what that means. I checked out w3schools Python tutorial on inheritance. (P.S. I LOVE W3Schools).

After checking out the section for Adding Methods, I see where I went wrong adding in the variables as parameters instead of the self keyword, which I now remember is what we do in Python for implementing methods in subclasses.

Success!

After running my code in the challenge code editor, I get the green success message. Challenge complete! 🎉

I hope you enjoyed this first post. I am new to blogging and one of my goals is to get better at it so if you have any questions or feedback, please feel free to leave a comment, or connect with me:

Twitter: @sarah_schlueter
Discord: sarahmarie73

Thanks for reading and happy coding!

Here's the final code for the challenge:

from abc import ABCMeta, abstractmethod
class Book(object, metaclass=ABCMeta):
    def __init__(self,title,author):
        self.title=title
        self.author=author   
    @abstractmethod
    def display(): pass

#Write MyBook class
class MyBook(Book):
    def __init__(self, title, author, price):
        super().__init__(title, author)
        self.price = price

    def display(self):
        print(f"Title: {title}")
        print(f"Author: {author}")
        print(f"Price: {price}")


title=input()
author=input()
price=int(input())
new_novel=MyBook(title,author,price)
new_novel.display()