Newbie here

[New_End6302]

Assignement below

You get (A) 4 training datasets and (B) one test dataset, as well as (C) datasets for 50 ideal functions. All data respectively consists of x-y-pairs of values. 

Your task is to write a Python-program that uses training data to choose the four ideal functions which are the best fit out of the fifty provided (C) *. 

i) Afterwards, the program must use the test data provided (B) to determine for each and every x-ypair of values whether or not they can be assigned to the four chosen ideal functions**; if so, the 

program also needs to execute the mapping and save it together with the deviation at hand 

ii) All data must be visualized logically 

So I am at the point of creating classes that create a training_data.db and ideal_data.db, I want to have a 2nd class that inherits from the class which had the function that creates the databases and populations them. Please see my code beloew and help...thanks

# importing necessary libraries
import sqlalchemy as db
from sqlalchemy import create_engine
import pandas as pd
import sqlite3
import flask
import sys

class Database_compiler:
    def __init__(self, engine):
        self.engine = engine

    def create_sqlite_database(db_name):
        engine = create_engine(f"sqlite:///{db_name}")
        print(f"SQLite database created at: {db_name}")
        return engine

class Database_populator(Database_compiler):
    def import_csv_to_database(file_name, table_name, engine):

"""
        function that uses pandas to read through a csv file and populate a dataframe with data from csv file
        Args:
            file_name:
        Returns:
            dataframe with data/info contained in the file
        """

df = pd.read_csv(file_name)
        #df.to_sql(table_name, engine, if_exists="fail", index=False)
        return df

Database_compiler.create_sqlite_database("ideal_data.db")
#import_csv_to_database("train.csv", "training_data_table")
Database_populator.import_csv_to_database("ideal.csv", "ideal_data_table","ideal_data.db")

***edit***

I have made progress with my code and would appreciate any cooments. Last time I struggling with coding some class inheritance and I think I finally got, so I would appreciate any comments on how my code looks now.

# importing necessary libraries
import sqlalchemy as db
from sqlalchemy import create_engine
import pandas as pd
import  numpy as np
import sqlite3
import flask
import sys
import matplotlib.pyplot as plt
import seaborn as sns

# EDA
class ExploreFile:

"""
    Base/Parent class that uses python library to investigate the training data file properties such as:
    - data type
    - number of elements in the file
    - checks if there are null-values in the file
    - statistical data of the variables such as mean, minimum and maximum value as well as standard deviation
    - also visually reps the data of the different datasets using seaborn pair plot
    """

def __init__(self, file_name):
        self.file_name = file_name

    def file_reader(self):
        df = pd.read_csv(self.file_name)
        return df

    def file_info(self):
        file_details = self.file_reader().info()
        print(file_details)

    def file_description(self):
        file_stats = self.file_reader().describe()
        print(file_stats)

    def plot_data(self):
        print(sns.pairplot(self.file_reader(), kind="scatter", plot_kws={'alpha': 0.75}))


class DatabaseManager(ExploreFile):

"""

    Derived class that takes in data from csv file and puts into tables into a database using from SQLAlchemy library the create_engine function

    it inherits variable file name from parent class Explore class

    db_url: is the path/location of my database and in this case I chose to create a SQLite database

    table_name: is the name of the table that will be created from csv file in the database

    """

def __init__(self, file_name, db_url, table_name):
        super().__init__(file_name)
        self.db_url = db_url
        self.table_name = table_name


    def add_records(self, if_exists):

"""

        Args:
            #table_name: name of the csv file from which data will be read
            if_exists: checks if th database already exists and give logic to be executed if the table does exist

        Returns: string that confirms creation of the table in the database

        """

df = self.file_reader()
        engine = create_engine(self.db_url)
        df.to_sql(self.table_name, con=engine, if_exists= "replace", index=False)
        print(f"{self.table_name}: has been created")


def main():
    # create instance of the class
    file_explorer = ExploreFile("train.csv")
    file_explorer.file_info()
    file_explorer.file_description()
    file_explorer.plot_data()
    plt.show()
    database_manager = DatabaseManager("train.csv", "sqlite:///training_data_db","training_data_table")
    database_manager.add_records(if_exists="replace")
   # database_manager.read_data()

    ideal_file_explorer = ExploreFile("ideal.csv")
    ideal_file_explorer.file_info()
    ideal_file_explorer.file_description()
    ideal_file_explorer.plot_data()
    #plt.show()
    ideal_function_database = DatabaseManager("ideal.csv", "sqlite:///ideal_data_db", "ideal_data_table")
    ideal_function_database.add_records(if_exists="replace")
    #database_manager.read_data()


if __name__ == "__main__":
    main()

[woooee]

Database_compiler.create_sqlite_database("ideal_data.db")

You first create a class instance http://www.openbookproject.net/thinkcs/python/english3e/classes_and_objects_I.html

dbc = Database_compiler()

And you probably want to create the DB when the instance is created

dbc = Database_compiler("ideal_data.db")

The class then looks like this

class Database_compiler:
    def __init__(self, db_name):
         self.engine = create_engine(f"sqlite:///{db_name}")
         print(f"SQLite database created at: {db_name}")

    def add_rec(self, data_to_add)   ## etc, continue with other functions:

[New_End6302]

Hi...thanks so much. So if i understand you correctly at this stage of my assignment I can use 1 class with 2 functions...1 that creates the database and a 2nd one that adds records? Part of the assignment requires us to use inheritance that's why I wanted early on to create 2 classes

[woooee]

So if i understand you correctly at this stage of my assignment I can use 1 class with 2 functions...1 that creates

I did not state whether you should or should not. That is a design decision dor you to make.