init

My_bd/config.yaml

@@ -0,0 +1,5 @@
+dbname: Test # В классе менять не надо
+user:  postgres # Замените на свой логин от БД в классе
+password: Qwerty # Замените на свой пароль от БД в классе
+host: localhost # Замените на 192.168.0.48 в классе
+dbtableprefix: "public."  # Замените на свой логин от БД

My_bd/dbconnection.py

@@ -0,0 +1,61 @@
+import psycopg2
+
+class DbConnection:
+    '''config это класс, который находится в файле config.yaml'''
+    def __init__(self, config):
+        '''это метод, который вызывается при создании объекта на основе класса DbConnection, 
+            и в нём задаются все ключевые параметры'''
+        self.dbname = config.dbname
+        self.user = config.user
+        self.password = config.password
+        self.host = config.host
+        self.prefix = config.dbtableprefix
+        ''' conn - это переменная/атрибут'''
+        ''' self.conn - это мы создаем атрибутт conn для ЭТОГО объекта и он хранит информацию о соединении с бд'''
+        self.conn = psycopg2.connect(dbname = self.dbname,
+                                    user = self.user, 
+                                    password = self.password,
+                                    host = self.host)
+
+    def __del__(self):
+        if self.conn:
+            self.conn.close()
+
+    # def dif_stations(self):
+    #     '''cursor - это посредник между питоном и бд'''
+    #     cur = self.conn.cursor()
+    #     cur.execute("DROP TABLE IF EXISTS stations CASCADE")
+    #     cur.execute("CREATE TABLE stations(st_id serial, st_name varchar(60), tarrif_zone_id integer, st_index integer)")
+    #     cur.execute("INSERT INTO stations(st_id, st_name, tarrif_zone_id, st_index) VALUES(1, 'Нахабино', 1,1)")
+    #     self.conn.commit()
+    #     cur.execute("SELECT * FROM stations")
+    #     result = cur.fetchall()
+    #     cur.execute("DROP TABLE stations")
+    #     self.conn.commit()
+    #     return (result[0][0] == 1)
+
+    # def dif_routes(self):
+    #     cur = self.conn.cursor()
+    #     cur.execute("DROP TABLE IF EXISTS routes CASCADE")
+    #     cur.execute("CREATE TABLE routes(route_id serial, first_st_id integer, last_st_id integer)")
+    #     cur.execute("INSERT INTO routes(route_id, first_st_id, last_st_id) VALUES(1,1,2)")
+    #     self.conn.commit()
+    #     cur.execute("SELECT * FROM routes")
+    #     result = cur.fetchall()
+    #     cur.execute("DROP TABLE routes")
+    #     self.conn.commit()
+    #     return (result[0][0] == 1)
+        
+    def test(self):
+        '''cursor - это посредник между питоном и бд'''
+        cur = self.conn.cursor()
+        cur.execute("DROP TABLE IF EXISTS test CASCADE")
+        cur.execute("CREATE TABLE test(test integer)")
+        cur.execute("INSERT INTO test(test) VALUES(1)")
+        self.conn.commit()
+        cur.execute("SELECT * FROM test")
+        result = cur.fetchall()
+        # cur.execute("DROP TABLE test")
+        self.conn.commit()
+        return (result[0][0] == 1)
+        

My_bd/dbtable.py

@@ -0,0 +1,84 @@
+from dbconnection import *
+
+class DbTable:
+    dbconn = None
+
+    def __init__(self):
+        return
+
+    def table_name(self):
+        return self.dbconn.prefix + "table"
+
+    def columns(self):
+        return {"test": ["integer", "PRIMARY KEY"]}
+
+    def column_names(self):
+        return sorted(self.columns().keys(), key = lambda x: x)
+
+    def primary_key(self):
+        return ['id']
+
+    def column_names_without_id(self):
+        res = sorted(self.columns().keys(), key = lambda x: x)
+        if 'id' in res:
+            res.remove('id')
+        return res
+
+    def table_constraints(self):
+        return []
+
+    def create(self):
+        sql = "CREATE TABLE " + self.table_name() + "("
+        arr = [k + " " + " ".join(v) for k, v in sorted(self.columns().items(), key = lambda x: x[0])]
+        sql += ", ".join(arr + self.table_constraints())
+        sql += ")"
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        self.dbconn.conn.commit()
+        return
+
+    def drop(self):
+        sql = "DROP TABLE IF EXISTS " + self.table_name()
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        self.dbconn.conn.commit()
+        return
+
+    def insert_one(self, vals):
+        for i in range(0, len(vals)):
+            if type(vals[i]) == str:
+                vals[i] = "'" + vals[i] + "'"
+            else:
+                vals[i] = str(vals[i])
+        sql = "INSERT INTO " + self.table_name() + "("
+        sql += ", ".join(self.column_names_without_id()) + ") VALUES("
+        sql += ", ".join(vals) + ")"
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        self.dbconn.conn.commit()
+        return
+
+    def first(self):
+        sql = "SELECT * FROM " + self.table_name()
+        sql += " ORDER BY "
+        sql += ", ".join(self.primary_key())
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        return cur.fetchone()        
+
+    def last(self):
+        sql = "SELECT * FROM " + self.table_name()
+        sql += " ORDER BY "
+        sql += ", ".join([x + " DESC" for x in self.primary_key()])
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        return cur.fetchone()
+
+    def all(self):
+        sql = "SELECT * FROM " + self.table_name()
+        sql += " ORDER BY "
+        sql += ", ".join(self.primary_key())
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        return cur.fetchall()        
+        

My_bd/functions.py

@@ -0,0 +1,16 @@
+def validate_input(prompt, min_value, max_value):
+    """Проверка ввода для выбора номера строки
+    """    
+    while True:
+        user_input = input(prompt)
+        try:
+            value = int(user_input)
+            if min_value <= value <= max_value and value != 0:
+                return value
+            elif value == 0:
+                return -1
+            else:
+                print(f"Введенное значение должно быть в диапазоне от {min_value} до {max_value}")
+        except ValueError:
+            print("Введенное значение должно быть числом.")
+        

My_bd/main.py

@@ -0,0 +1,249 @@
+import sys
+import functions
+sys.path.append('tables')
+
+from project_config import *
+from dbconnection import *
+from tables.stations_table import *
+from tables.routes_table import *
+
+class Main:
+
+    config = ProjectConfig()
+    connection = DbConnection(config)
+
+    def __init__(self):
+        DbTable.dbconn = self.connection
+        return
+
+    def db_init(self):
+        st = StationTable()
+        rt = RoutesTable()
+        st.create()
+        rt.create()
+        return
+
+    def db_insert_somethings(self):
+        st = StationTable()
+        rt = RoutesTable()
+        
+        st.example_insert()
+        rt.example_insert()
+        
+    def db_drop(self):
+        rt = RoutesTable()
+        st = StationTable()
+        rt.drop()
+        st.drop()
+        return
+
+            
+    def show_main_menu(self):
+        menu = """Добро пожаловать! 
+Основное меню (выберите цифру в соответствии с необходимым действием): 
+    1 - просмотр станций;
+    2 - сброс и инициализация таблиц;
+    10 - выход."""
+        print(menu)
+        return
+
+    def read_next_step(self):
+        return input("=> ").strip()
+
+    def after_main_menu(self, next_step):
+        if next_step == "2":
+            self.db_drop()
+            self.db_init()
+            self.db_insert_somethings()
+            print("Таблицы созданы заново!")
+            return "0"
+        elif next_step != "1" and next_step != "10":
+            print("Выбрано неверное число! Повторите ввод!")
+            return "0"
+        else:
+            return next_step
+            
+    def show_stations(self):
+        self.st_id = -1
+        self.st_arr = []
+        self.max_name_len = 0
+        lst = StationTable().all()
+        self.max_st_index = len(lst)
+        for i in lst:
+            self.st_arr.append([str(i[2]), str(i[3]), str(i[1])])
+            self.max_name_len = max(self.max_name_len, len(str(i[2])))
+        
+        menu = f"""Просмотр списка станций.
+№\tНазвание {" "*(self.max_name_len-4)}Тарифная зона{" " *3}Индекс\n\
+----------------------------------------------------------------"""
+        print(menu)
+        for i in range(len(lst)):
+            txt = str(i+1) + "\t"
+            txt += self.st_arr[i][0] + " "*(4+self.max_name_len-len(self.st_arr[i][0]))
+            txt += self.st_arr[i][1] + " "*(13 - len(self.st_arr[i][1]) + 3) + self.st_arr[i][2]
+            print(txt)
+        menu = """Дальнейшие операции: 
+    0 - возврат в главное меню;
+    4 - удаление станции;
+    5 - добавление станции;
+    6 - изменение названия станций;
+    7 - просмотр маршрутов;
+    9 - добавление маршрута(с использованием станций);
+    10 - выход."""
+        print(menu)
+        return
+
+    def after_show_stations(self, next_step):
+        while True:
+            if next_step == "4":#delete station
+                x = functions.validate_input('Введите номер удаляемой станции (0 - для отмены): ', 0, self.max_st_index)
+                if(x!=-1):
+                    StationTable().delete(self.st_arr[int(x)-1])
+                    print('Станция успешно удалена')
+                return "1"
+
+            elif next_step == "5":#insert station
+                StationTable().insert()
+                print('Станция успешно добавлена')
+                return "1"
+            
+            elif next_step == "6":#update station
+                x = functions.validate_input('Введите номер изменяемой станции (0 - для отмены): ', 0, self.max_st_index)
+                if(x!=-1):
+                    StationTable().update(self.st_arr[int(x)-1])
+                    print('Станция успешно изменена')
+                return "1"
+            
+            elif(next_step == "8"): # delete route
+                if(self.st_id != -1):
+                    x = functions.validate_input('Введите номер удаляемого маршрута (0 - для отмены): ', 0, self.max_rt_index)
+                    if(x!=-1):
+                        RoutesTable().delete(self.rt_arr[int(x)-1])
+                        print('Маршрут успешно удален')
+                    else:
+                        next_step = "7"
+                        return "1"
+                else:
+                    print("Необходимо выбрать станцию")
+                    return "1"
+                
+                
+            elif next_step == "7":#show routes
+                self.show_routes_with_station()
+        
+            elif next_step == "9":#insert route
+                RoutesTable().insert(self.max_st_index)
+                print('Маршрут успешно добавлен')
+                return "1"
+                
+            elif next_step != "0" and next_step != "10":
+                print("Выбрано неверное число! Повторите ввод!")
+                return "1"
+            else:
+                return next_step
+            
+            
+    def show_routes_with_station(self):
+        """Вывод всех маршрутов по введенной станции
+        """       
+        self.routes_arr = []
+        if self.st_id == -1:
+            while True:
+                t = functions.validate_input('Вывести маршрут по:\
+            \n1 - начальной станции;\
+            \n2 - конечной станции;\n', 0, 2)
+                if t == 1:
+                    x = functions.validate_input('Выберите номер интересуемой строки с начальной станцией (0 - отмена): ', 0, self.max_st_index)
+                    if(x==-1):
+                        return
+                    else:
+                        self.st_id = StationTable().find_by_name(self.st_arr[x-1][0])
+                        self.st_obj = self.st_arr[x-1][0]
+                    lst = RoutesTable().all_by_st_id(self.st_id, 1)
+                    self.max_rt_index = len(lst)
+                    if lst == []:
+                        print('Нет маршрута с такой начальной станцией')
+                    else:
+                        print("Выбрана station: " + self.st_obj)
+                        print("Маршруты:")
+                        print("№\tНомер маршрута\tВыбранная станция\tКонечная станция\
+                                \n--------------------------------------------------------")
+                        for i in lst:
+                            self.routes_arr.append([str(i[0]), str(i[2]), i[1]])
+                                
+                        for i in range(len(self.routes_arr)):
+                            output = f"""{str(i+1)}\t{str(self.routes_arr[i][2])} \t\t\
+        {self.st_obj}\t\t{str(StationTable().name_by_id(self.routes_arr[i][1])[0])}"""
+                            print(output)
+                        menu = """Дальнейшие операции:
+0 - возврат в главное меню;
+1 - возврат в просмотр станций;
+8 - удаление маршрута;
+10 - выход."""
+                        print(menu)
+                        return self.read_next_step()
+                
+                elif t == 2:
+                    x = functions.validate_input('Выберите номер интересуемой строки с конечной станцией (0 - отмена): ', 0, self.max_st_index)
+                    if(x==0):
+                        return
+                    else:
+                        self.st_id = StationTable().find_by_name(self.st_arr[x-1][0])
+                        self.st_obj = self.st_arr[x-1][0]
+                    lst = RoutesTable().all_by_st_id(self.st_id, 2)
+                    self.max_rt_index = len(lst)
+                    if lst == []:
+                        print('Нет маршрута с такой конечной станцией')
+                    else:
+                        print("Выбрана station: " + self.st_obj)
+                        print("Маршруты:")
+                        print("№\tНомер маршрута\tВыбранная станция\tНачальная станция\
+                                \n--------------------------------------------------------")
+                        for i in lst:
+                            self.routes_arr.append([str(i[0]), str(i[2]), i[1]])
+                                
+                        for i in range(len(self.routes_arr)):
+                            output = f"""{str(i+1)}\t{str(self.routes_arr[i][1])} \t\t\
+        {self.st_obj}\t\t{str(StationTable().name_by_id(self.routes_arr[i][0])[0])}"""
+                            print(output)
+                        
+                        menu = """Дальнейшие операции:
+            0 - возврат в главное меню;
+            1 - возврат в просмотр станций;
+            8 - удаление маршрута;
+            10 - выход."""
+                        print(menu)
+                        return self.read_next_step()
+                else:
+                    print("Неверный ввод!")
+        
+    def main_cycle(self):
+        current_menu = "0"
+        next_step = None
+        while(current_menu != "10"):
+            if current_menu == "0":
+                self.show_main_menu()
+                next_step = self.read_next_step()
+                current_menu = self.after_main_menu(next_step)
+                
+            elif current_menu == "1":
+                self.show_stations()
+                next_step = self.read_next_step()
+                current_menu = self.after_show_stations(next_step)
+                
+            # elif current_menu == "2":
+            #     self.show_main_menu()
+            #     current_menu = "1"
+                
+        print("До свидания!")    
+        return
+
+    def test(self):
+        DbTable.dbconn.test()
+
+m = Main()
+# Откоментируйте эту строку и закоментируйте следующую для теста
+# соединения с БД
+# m.test()
+m.main_cycle()
+    

My_bd/project_config.py

@@ -0,0 +1,21 @@
+# Загрузка настроек проекта (в данном случае только настроек соединения с БД)
+# из файла config.yaml.
+import yaml
+
+class ProjectConfig:
+    """Класс считывает базовые настройки из файла config.yaml"""
+
+    def __init__(self):
+        with open('config.yaml') as f:
+            config = yaml.safe_load(f)
+            self.dbname = config['dbname']
+            self.user = config['user']
+            self.password = config['password']
+            self.host = config['host']
+            self.dbtableprefix = config['dbtableprefix']
+
+# Этот метод запускается только, если запускать
+# данный файл, а не подключать его.
+if __name__ == "__main__":
+    x = ProjectConfig()
+    print(x.dbfilepath)

My_bd/tables/routes_table.py

@@ -0,0 +1,91 @@
+from tables.stations_table import *
+from dbtable import *
+import functions
+
+class RoutesTable(DbTable):
+    def table_name(self):
+        return self.dbconn.prefix + "routes"
+
+    def columns(self):
+        return {"id": ["serial", "PRIMARY KEY"],
+                "first_st_id": ["integer", "NOT NULL", "REFERENCES stations(id) ON DELETE CASCADE"],
+                "last_st_id": ["integer", "NOT NULL", "REFERENCES stations(id) ON DELETE CASCADE"]}
+    
+    def primary_key(self):
+        return ['id']    
+
+    '''def table_constraints(self):
+        return ["PRIMARY KEY(route_id)"]'''
+
+                
+    def all_by_st_id(self, pid, t):
+        if(t == 1):
+            sql = f"""SELECT * FROM {self.table_name()} WHERE first_st_id = {str(pid)} ORDER BY {", ".join(self.primary_key())};"""
+        else:
+            sql = f"""SELECT * FROM {self.table_name()} WHERE last_st_id = {str(pid)} ORDER BY {", ".join(self.primary_key())};"""
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        return cur.fetchall()      
+    
+    def delete(self, val):
+        par_sql = "DELETE FROM routes WHERE st_name = %s"
+        cur = self.dbconn.conn.cursor()
+        value = "".join(val)
+        cur.execute(par_sql, (value,))
+        self.dbconn.conn.commit()
+        
+    def insert(self, max_index):
+        while True:
+            first_st_id = functions.validate_input('Введите номер добавляемой начальной станции (0 - для отмены): ', 0, max_index)
+            if(first_st_id == -1): return "1"
+            last_st_id = functions.validate_input('Введите номер добавляемой конечной станции (0 - для отмены): ', 0, max_index)
+            if(last_st_id == -1): return "1"
+            t1 = StationTable().index_by_id(first_st_id)
+            t2 = StationTable().index_by_id(last_st_id)
+            if t1>t2:
+                print('Нельзя добавить такой маршрут')
+            else:
+                insert = [first_st_id, last_st_id]
+                self.insert_one(insert)
+                return
+        
+    def update(self, max_index):
+        while True:
+            t = functions.validate_input('Изменить маршрут по:\
+            \n1 - начальной станции;\
+            \n2- конечной станции;\n', 0, 2)
+            if(t==1):
+                n1 = functions.validate_input('Введите номер начальной станции, который вы хотите заменить (0 - для отмены): ', 0, max_index)
+                if(n1 == -1): return "1"
+                n2 = functions.validate_input('Введите номер, на который вы хотите поменять (0 - для отмены): ', 0, max_index)
+                if(n2 == -1): return "1"
+                if n1 != n2:
+                    sql = f"""UPDATE {self.table_name()} SET first_st_id = '{n2}' WHERE first_st_id = '{n1}';"""
+                    # sql2 = f"""UPDATE stations SET id = '{n2}' WHERE id = '{n1}';"""
+                    break
+                else:
+                    print('Невозможно поменять на такой номер')
+            elif(t==2):
+                n1 = functions.validate_input('Введите номер конечной станции, который вы хотите заменить (0 - для отмены): ', 0, max_index)
+                if(n1 == -1): return "1"
+                n2 = functions.validate_input('Введите номер, на который вы хотите поменять (0 - для отмены): ', 0, max_index)
+                if(n2 == -1): return "1"
+                if n1 != n2:
+                    sql = f"""UPDATE {self.table_name()} SET last_st_id = '{n2}' WHERE last_st_id = '{n1}';"""
+                    # sql2 = f"""UPDATE stations SET id = '{n2}' WHERE id = '{n1}';"""
+                    break
+                else:
+                    print('Невозможно поменять на такой номер')
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql)
+        self.dbconn.conn.commit()
+        return
+    
+    def example_insert(self):
+        self.insert_one([1,2])
+        self.insert_one([1,6])
+        self.insert_one([1,7])
+        self.insert_one([1,8])
+        self.insert_one([1,9])
+        self.insert_one([1,6])
+        return

My_bd/tables/stations_table.py

@@ -0,0 +1,137 @@
+from dbtable import *
+import functions
+
+class StationTable(DbTable):
+    '''
+    Это класс для таблиц 
+    '''
+    def table_name(self):
+        '''
+        Это метод для названия таблицы
+        '''
+        return self.dbconn.prefix + "stations"
+
+    def columns(self):
+        return {"id": ["serial", "PRIMARY KEY"],
+                "st_name": ["varchar(60)", "NOT NULL"],
+                "tarrif_zone_id": ["integer", "NOT NULL"],
+                "st_index": ["integer", "NOT NULL"]}
+
+    def table_constraint(self):
+        return ['CONTRAINT "Name" UNIQUE (st_name)']
+    
+    def find_by_position(self, num):
+        sql = "SELECT * FROM " + self.table_name()
+        sql += " ORDER BY "
+        sql += ", ".join(self.primary_key())
+        sql += " LIMIT 1 OFFSET %(offset)s"
+        cur = self.dbconn.conn.cursor()
+        cur.execute(sql, {"offset": num - 1})
+        return cur.fetchone()   
+    
+    def delete(self, val):
+        par_sql = f"DELETE FROM stations WHERE st_name = '{val[0]}';"
+        cur = self.dbconn.conn.cursor()
+        cur.execute(par_sql)
+        self.dbconn.conn.commit()
+        
+    def insert(self):
+        while True:
+            st_name = input('Введите название добавляемой станции (enter - отмена): ').strip()
+            if len(st_name) > 60:
+                print('Недопустмая длина названия станции')
+            elif st_name == '':
+                return "1"
+            else:
+                break
+        tarrif_zone_id = functions.validate_input('Введите номер тарифной зоны: ', 0, 7)
+        if(tarrif_zone_id==-1):
+            return "1"
+        st_index = functions.validate_input('Введите индекс добавляемой станции: ', 0, 100)
+        if(st_index==-1):
+            return "1"
+        insert = [st_index, st_name, tarrif_zone_id]
+        self.insert_one(insert)
+            
+
+    def update(self, old):
+        """Функция для обновления категории
+        """      
+        print(f'''Выбрана станция для изменения: {old[0]}''')
+        cur = self.dbconn.conn.cursor()
+        while True:
+            data = input("Введите название (enter - отмена): ").strip()
+            if(len(data.strip()) > 60):
+                data = input("Название слишком длинное! Введите название заново (enter - отмена):").strip()
+            elif(self.check_by_name(data.strip())):
+                data = input("Такое название уже существует. Введите новое (enter - отмена):").strip()
+            elif(data==''): return 
+            else:
+                param_sql = f"UPDATE {self.table_name()} SET st_name = '{data}' WHERE st_name = '{old[0]}';"
+                cur.execute(param_sql)
+                self.dbconn.conn.commit()
+                return
+    
+    def check_by_name(self, value): 
+        sql = f"SELECT * FROM {self.table_name()} WHERE st_name='{value}'"  
+        cur = self.dbconn.conn.cursor() 
+        cur.execute(sql) 
+        result = cur.fetchone() 
+        cur.close() 
+        if result: 
+            return True 
+        else: 
+            return False
+
+    def find_by_name(self, name):
+        cur = self.dbconn.conn.cursor()
+        param_query = "SELECT id FROM Stations WHERE st_name = %s;"
+        # sql_sel = "SELECT id FROM " + self.table_name()
+        # sql_sel += " WHERE cath_name = " + "'" + name + "'" + ";"
+        cur.execute(param_query, (name,))           
+        ret = cur.fetchone()
+        return  list(ret)[0] 
+    
+    def name_by_id(self, id):
+        cur = self.dbconn.conn.cursor()
+        query = "SELECT st_name FROM Stations WHERE id = %s;"
+        cur.execute(query, str(id))
+        return cur.fetchone()
+
+    def index_by_id(self,id):
+        cur = self.dbconn.conn.cursor()
+        query = "SELECT st_index FROM Stations WHERE id = %s;"
+        cur.execute(query, str(id))
+        return cur.fetchone()
+    
+    def example_insert(self):
+        self.insert_one([1, "Нахабино", 1])
+        self.insert_one([2, "Стрешнево", 2])
+        self.insert_one([2, "Царицыно", 2])
+        self.insert_one([3, "Яуза", 3])
+        self.insert_one([2, "Щукинская", 3])
+        self.insert_one([4, "Москва-Курская", 4])
+        self.insert_one([4, "Дмитровская", 4])
+        self.insert_one([4, "Остафьево", 4])
+        self.insert_one([4, "Подольск", 4])
+        return
+        
+# класс человек:
+#     атрибуты(имя, фамилия, возраст)
+#     методы(пукнуть, моргнуть)
+
+# класс женщина(человек):
+#     атрибуты(размер груди)
+#     методы(краситься, купить бюстгалтер)
+
+#     def buy_lifchik(self, size):
+#         пойти в магазин и купить лифчик размер size
+
+# Катя = женщина(Катя, Ускова, 19, 3-4)
+
+# Саша = женщина(Саша, Антипенко, 14, 1)
+
+# катя.купить бюстгалтер()
+# саша.купить бюстгалтер()
+
+