from KatalogSamochodow import Katalog
import subprocess
import sys


def install(package):
    subprocess.call([sys.executable, "-m", "pip",
                     "install", "--user", package])

'''
Jeżeli __main__  posiada prefix "__main__"
zainstaluj wszystkie zależności.

'''
if __name__ == "__main__":
    print("Fullfilling dependencies")
    install('termcolor')
    print("finished.")

'''
Zmienna globalna.
'''
Lista = Katalog()
# Conditional Lambda

'''
Parametryzowalne funkcje lambda.
'''
def YearNotLowerThan(x):
    return lambda value: value.rocznik > x


def VolumeNotLowerThan(x):
    return lambda value: value.pojemnosc > x


def MileageNotLowerThan(x):
    return lambda value: value.przebieg > x


def YearLowerThan(x):
    return lambda value: value.rocznik < x


def VolumeLowerThan(x):
    return lambda value: value.pojemnosc < x


def MileageLowerThan(x):
    return lambda value: value.przebieg < x


'''
Warnki wyświelania samochodów w liście obiektów typu tuple.
'''
Conditions = [
    (1, "Przebieg nie mniejszy niż X", MileageNotLowerThan),
    (2, "Pojemność nie mniejsza niż X", VolumeNotLowerThan),
    (3, "Rok nie mniejszy niż X", YearNotLowerThan),
    (4, "Przebieg mniejszy niż X", MileageLowerThan),
    (5, "Pojemność mniejsza niż X", VolumeLowerThan),
    (6, "Rok mniejszy niż X", YearNotLowerThan),
]

'''
    Lista sposobów sorowania.
'''
Sort = [
    (1, "Rok Produkcji(malejąco)", ("rocznik", True)),
    (2, "Rok Produkcji(rosnąco)", ("rocznik", False)),
    (3, "Pojemność silnika(malejąco)", ("pojemnosc", True)),
    (4, "Pojemność silnika(rosnąco)", ("pojemnosc", False)),
    (5, "Przebieg(malejąco)", ("przebieg", True)),
    (6, "Przebieg(rosnąco)", ("przebieg", False)),

]
# functions

def LoadFromFile():
    FileLocation = \
        input("Proszę podać lokalizacjię pliku (adres względny):")
    Lista.LoadFromFile(FileLocation)


def SaveToFile():
    FileLocation =\
        input("Proszę podać miejsce zapisu pliku(adres względny):")
    Lista.SaveToFile(FileLocation)

'''
    1.Wyświetl wszystkie elemeny listy Conditions.
    2.Pobierz opcję wybraną przez użytkownika.
    3.Znajdź wartość w liście (pierwszy element typu tuple)
    4.Ustaw wartość w celu stworzenia parameryzowalnej lambdy.
    5.Użyj parametryzowalnej lambdy jako argumentu do funkcji.

'''
def ConditionalList():
    for Index, Message in [(x[0], x[1]) for x in Conditions]:
        print(str(Index) + ". " + Message)
    Decision = int(input("Opcja: "))
    for condition in Conditions:
        if Decision == condition[0]:
            Decision = int(input("Wartość: "))
            Lista.ConditionalList(condition[2](Decision))

'''
    1.Wyświetl wszystkie elemeny listy Conditions.
    2.Pobierz opcję wybraną przez użytkownika.
    3.Znajdź wartość w liście (pierwszy element typu tuple)
    4.Użyj parametryzowalnej lambdy jako argumentu do funkcji.

'''
def SortedList():
    for Index, Message in [(x[0], x[1]) for x in Sort]:
        print(str(Index) + ". " + Message)
    Decision = int(input("Opcja: "))
    for condition in Sort:
        if Decision == condition[0]:
            Lista.SortCars(condition[2])

'''
    Dodaj samochód
'''
def AddCar():
    model = input("Proszę podać model samochodu: ")
    marka = input("Proszę podać markę samochodu: ")
    rocznik = int(input("Proszę podać rok produkcji samochodu: "))
    pojemnosc = float(input("Proszę podać pojemność silnika samochodu(w litrach): "))
    przebieg = int(input("Proszę podać przebieg samochodu: "))
    typskrzyni = int(
        input("Proszę podać rodzaj skrzyni biegów(1 - auto, 0 - man):"))
    Lista.AddCar(model, marka, rocznik, pojemnosc, przebieg, typskrzyni)

'''
    Usuń samochód
'''
def RemoveCar():
    Index = int(input("Proszę podać numer index samochodu: "))
    Lista.RemoveCar(Index)
def ShowCar():
    index = int(input("Proszę podać indeks samochodu: "))
    Lista.ShowSingleCar(index)

'''
    Lista dostępnych opcji w menu.
    Każda opcja jest typu tuple
'''
MenuList = [
    (1, "Wczytaj listę samochodów z pliku", LoadFromFile),
    (2, "Zapisz listę samochodów do pliku", SaveToFile),
    (3, "Wyświetl listę", Lista.showCars),
    (4, "Wyświetl listę na podstawie warunku", ConditionalList),
    (5, "Wyświetl listę posortowaną wg. warunku", SortedList),
    (6,"Wyświetl samochód o indeksie", ShowCar),
    (7, "Dodaj Samochód", AddCar),
    (8, "Usuń samochód", RemoveCar),
    (0, "Koniec Programu", exit)
]

'''
    Główna pętla programu.
'''
def main():
    while True:
        for Index, Message in [(x[0], x[1]) for x in MenuList]:
            print(str(Index)+". " + Message)
        Decision = int(input("Opcja: "))
        for condition in MenuList:
            if Decision == condition[0]:
                condition[2]()
        print("")

'''
    jeżeli __name__ = "__main__"
    wejdź do głownej pętli.
'''
if __name__ == "__main__":

    main()


2ga klasa

from Car import Car
import copy
from operator import itemgetter, attrgetter, methodcaller
import termcolor


class Katalog:
    '''
    Konstruktor klasy Katalog.
    musi ona posiadać tylko i wyłącznie pustą listę.
    '''
    def __init__(self):
        self.Cars = []
        pass
    '''
    Wczytywanie samochodów z pliku oraz dodawanie ich do listy.
    '''

    def LoadFromFile(self, Location: str):
        List = open(Location)
        for Object in List.readlines():
            Object = Object.replace("\n", "")
            Obj = Object.split('|')
            self.Cars.append(
                Car.Car(Obj[0],
                        Obj[1], int(Obj[2]),
                        float(Obj[3]), int(Obj[4]),
                        int(Obj[5])))
        List.close()
    '''
    Zapisz Samochody do listy.
    '''
    def SaveToFile(self, File: str):
        List = open(File, "w")
        for Car in self.Cars:
            List.write(Car.__serialize__() + "\n")
        List.close()
    '''
    Wyświetlanie samochodów w liście.
    '''
    def showCars(self):
        print(termcolor.colored("Lista samochodów", 'red'))
        for A in range(0, self.Cars.__len__()):
            print("Index samochodu:" + str(A))
            print(self.Cars[A])
        print(termcolor.colored("Koniec listy samochodów", 'red'))
    '''
    Ujednolicona Lista warunkowa.
    Condition jest funkcją typu lambda która jest wykonywana
    dla każdego elementu w liście.
    '''
    def ConditionalList(self, condition):
        print(termcolor.colored("Lista samochodów", 'red'))
        for A in range(0, self.Cars.__len__()):
            if condition(self.Cars[A]):
                print("Index samochodu:" + str(A))
                print(self.Cars[A])
        print(termcolor.colored("Koniec listy samochodów", 'red'))
    '''
    Wyświetlenie samochodu na podstawie indeksu.
    '''
    def ShowSingleCar(self, index: int):
        if index > self.Cars.__len__() and index < 0:
            print(termcolor.colored("Samochod o takim indexie nie istnieje", 'red'))
        else:
            print("Samochód o numerze indeksu: " + str(index))
            print(self.Cars[index])
        pass
    '''
    Sortowanie samochodów na podstawie parametru.
    parametr jest funkcją lambda.
    '''
    def SortCars(self, parameter):
        SortedList = copy.deepcopy(self.Cars)
        SortedList.sort(key=attrgetter(parameter[0]), reverse=parameter[1])
        print(termcolor.colored("Posortowana lista", 'red'))
        for A in range(0, self.Cars.__len__()):
            print(SortedList[A])
        print(termcolor.colored("Koniec listy samochodów", 'red'))
    '''
    dodanie samochodu do listy.
    '''
    def AddCar(self, marka: str, model: str,
               rocznik: int, pojemnosc: float, przebieg: int, TypSkrzyni: bool):
        self.Cars.append(
            Car.Car(
                marka, model,
                rocznik, pojemnosc,
                przebieg, TypSkrzyni)
        )
        pass
    '''usunięcie samochodu o określonym indeksie.'''
    def RemoveCar(self, index):
        if index > self.Cars.__len__() and index < 0:
            print(termcolor.colored("Samochod o takim indexie nie istnieje", 'red'))
        else:
            del self.Cars[index]



3 klasa

class Car:
    '''
    Konstrukor klasy Car.
    Przypisuje wartości podstawowych pól klasy.
    '''
    def __init__(self, marka: str, model: str,
                 rocznik: int, pojemnosc: float, przebieg: int, TypSkrzyni: int):
        self.marka = marka
        self.model = model
        self.rocznik = rocznik
        self.pojemnosc = pojemnosc
        self.przebieg = przebieg
        self.TypSkrzyni = TypSkrzyni
    '''
    Pomocna funkcja która zwraca wartość typu string
    o aktualnym typie skrzyni samochodu.
    '''
    def typSkrzyni(self):
        if self.TypSkrzyni == 1:
            return "Automatyczna"
        else:
            return "Manualna"
    '''
    Przeciążona metoda specialna dostępna wyłącznie w języku python.
    funkcja print() zawsze wywołuje tą metodę aby uzyskać informacje o
    obiekcie.
    W tym przypadku zwracamy w czytelny sposób informacje.
    '''
    def __str__(self):
        Sttr = ""
        Sttr += "Marka: " + self.marka + "\n"
        Sttr += "Model: " + self.model + "\n"
        Sttr += "Rocznik: " + str(self.rocznik) + "\n"
        Sttr += "Pojemność: " + str(self.pojemnosc) + "\n"
        Sttr += "Przebieg: " + str(self.przebieg) + "\n"
        Sttr += "Typ Skrzyni: " + self.typSkrzyni()+"\n"
        Sttr += "\n"
        return Sttr
    '''
    Serializowanie obiektu.
    '''
    def __serialize__(self):
        Sttr = ""
        Sttr += self.marka            \
            + "|" + self.model            \
            + "|" + str(self.rocznik)     \
            + "|" + str(self.pojemnosc)   \
            + "|" + str(self.przebieg)    \
            + "|" + str(self.TypSkrzyni)
        return Sttr