Witam,

Próbuję napisać program, który sparsuje xml do postgresql z możliwością zarządzania: wyszukiwanie, dodawanie, edycja, usuwanie danych z bazy. Otrzymuje ciągle nowe błędy i nie znajduję rozwiązania. Czy mogę prosić o pomoc w zdebugowaniu poniższego kodu?

'''python

-- coding: UTF-8 --

import sqlite3
import xml.etree.ElementTree
import ConfigParser
import sys

class DatabaseConnection:

@staticmethod
def path():
    path_choice = raw_input("""Czy chcesz zmienic sciezke do pliku xml?
    Domyslna sciezka to: c:/users/user/pycharmprojects/plants.xml
    [1] Tak
    [2] Nie
    """)
    if path_choice == "1":

        path_input = raw_input("Podaj sciezke do pliku: ")
        config = ConfigParser.ConfigParser()
        config.set('path', path_input)
        path_to_file = config.read(config, 'config', path_input)
    elif path_choice == "2":

        config = ConfigParser.ConfigParser()
        config.read("c:\users\user\pycharmprojects\plants\config.ini")
        path_to_file = config.get(config, 'config', 'path')

    return path_choice

    #łącznie z baza
def __init__(self):
    try:
        self.path()
        self.connection = sqlite3.connect("dawid.db")
        self.connection.autocommit = True
        self.cursor = self.connection.cursor()
        #self.create_table()
        self.insert_common()
        self.insert_botanical()
        self.insert_zone()
        self.insert_light()
        self.insert_price()
        self.insert_availability()

    except:
        print("cannot create db")
#utworzenie tabeli
#def CreateTable(self):
    #crete_table_command = "CREATE TABLE IF NOT EXISTS plants (id serial PRIMARY KEY, common text, botanical text, zone integer, light text, price float, availability integer)"
    #self.cursor.execute(crete_table_command)
# wprowadzam 1 kolumne
def InsertCommon(self):
    elem = ET.parse(path_to_file)
    common = elem.findall('PLANT/COMMON')
    for x in common:
        common_text = x.text
        insert_common = ("INSERT INTO plants (common) VALUES(?)", (common_text[0]))
        self.cursor.execute(insert_common)
# 2 kolumna
def InsertBotanical(self):
    elem = ET.parse(path_to_file)
    botanical = elem.findall('PLANT/BOTANICAL')
    for y in botanical:
        botanical_text = y.text
        print botanical_text
        insert_botanical = ("INSERT INTO plants (botanical) VALUES(?)", (botanical_text[0]))
        self.cursor.execute(insert_botanical)
# 3 kolumna itd...
def InsertZone(self):
    elem = ET.parse(path_to_file)
    zone = elem.findall('PLANT/ZONE')
    for z in zone:
        zone_insert = z.text
        print zone_insert
        try:
            insert_zone = ("INSERT INTO plants (zone) VALUES(?)", (zone_insert))
            self.cursor.execute(insert_zone)
            break
        except ValueError:
            print "Incorrect data type"

def InsertLight(self):
    elem = ET.parse(path_to_file)
    light = elem.findall('PLANT/LIGHT')
    for k in light:
        light_text = k.text
        print light_text
        insert_light = ("INSERT INTO plants (light) VALUES(?)", (light_text[0]))
        self.cursor.execute(insert_light)

def InsertPrice(self):
    elem = ET.parse(path_to_file)
    price = elem.findall('PLANT/PRICE')
    for n in price:
        price_insert = n.text
        print price_insert
        try:
            insert_price = ("INSERT INTO plants (zone) VALUES(?)", (price_insert))
            self.cursor.execute(insert_price)
            break
        except ValueError:
            print "Incorrect data type"

def InsertAvailability(self):
    elem = ET.parse(path_to_file)
    availability = elem.findall('PLANT/AVAILBILITY')
    for m in availability:
        availability_insert = m.text
        print availability_insert
        try:
            insert_availability = ("INSERT INTO plants (zone) VALUES(?)", (availability_insert))
            self.cursor.execute(insert_availability)
            break
        except ValueError:
            print "Incorrect data type"

print "============= PLANTONIX 30000 ================"
# menu dla usera

print "\nWybierz co chcesz zrobić: "
print "[1] Edytować dane"
print "[2] Dodać dane"
print "[3] Usunąć dane"
print "[4] Wyszukać w bazie"

#przechowuje opcje ktora wybrl user
choice = raw_input("Opcja: ")

def SearchInput():
    search_value = raw_input("""
    Po jakiej wartości chcesz szukać?
    [1] Nazwa
    [2] Lokalizacja
    [3] Nazwa botaniczna 
    [4] Dostępności
    [5] Cenie
    [6] Typie oświetlenia
    """)
    return

#   Wyszukiwanie rośliny w bazie
def SearchDBName(self):
    if search_value == "1":
        prompt_name = raw_input("podaj nazwę rośliny: ")
        sql_name_select = "SELECT common FROM plants where common == ? '" + prompt_name + "'"
        self.cursor.execute(sql_name_select)
        print sql_name_select
        return sql_name_select
    elif search_value == "2":
        prompt_localization = raw_input("podaj lokalizcje: ")
        sql_localization_select = "SELECT zone FROM plants WHERE zone == ? '" + prompt_localization + "'"
        self.cursor.execute(sql_localization_select)
        print sql_localization_select
        return sql_localization_select
    elif search_value == "3":
        prompt_botanical = raw_input("podaj nazwe botaniczna: ")
        sql_botanical_select = "SELECT botanical FROM plants WHERE botanical == ? '" + prompt_botanical + "'"
        self.cursor.execute(sql_botanical_select)
        print sql_botanical_select
        return sql_botanical_select
    elif search_value == "4":
        prompt_availab = raw_input("podaj dostepnosc: ")
        sql_availab_select = "SELECT availability FROM plants WHERE availability == ? '" + prompt_availab + "'"
        self.cursor.execute(sql_availab_select)
        print sql_availab_select
        return sql_availab_select
    elif search_value == "5":
        prompt_price = raw_input("podaj cene: ")
        sql_price_select = "SELECT price FROM plants WHERE price == ? '" + prompt_price + "'"
        self.cursor.execute(sql_price_select)
        print sql_price_select
        return sql_price_select
    elif search_value == "6":
        prompt_light = raw_input("podaj typ oswietlenia: ")
        sql_light_select = "SELECT light FROM plants WHERE light = ? '" + prompt_light + "'"
        self.cursor.execute(sql_light_select)
        print sql_light_select
        return sql_light_select
    else:
        print "Nie udalo sie wyszukac danych"

def EditInput():
    print "Wybierz rekord który chcesz edytować: "
    search_input()
    search_db_name()
    edit_field = raw_input("""Wybierz jaką wartość chcesz edytować: 
    [1] Nazwa
    [2] Nazwa botaniczna
    [3] Lokalizacja
    [4] Typ oswietlnia
    [5] Cena
    [6] Dostepnosc
    """)

def EditData(self):
    if edit_field == "1":
        new_name = raw_input("Podaj nowa nazwe: ")
        new_name_update = ("UPDATE plants SET common WHERE common = ? " + "'" + new_name + '"')
        self.cursor.execute(new_name_update)

    elif edit_field == "2":
        new_botanical = raw_input("Podaj nowa nazwe botaniczna: ")
        new_botanical_update = ("UPDATE plants SET botanical WHERE botanical = ? " + "'" + new_botanical + "'")
        self.cursor.execute(new_botanical_update)

    elif edit_field == "3":
        new_localization = raw_input("Podaj nowa lokalizacje: ")
        new_localization_update = ("UPDATE plants SET zone WHERE zone = ? " + "'" + new_localization + "'")
        self.cursor.execute(new_localization_update_update)

    elif edit_field == "4":
        new_light = raw_input("Podaj nowy typ oswietlenia: ")
        new_light_update = ("UPDATE plants SET light WHERE light = ? " + "'" + new_light + "'")
        self.cursor.execute(new_light_update)

    elif edit_field == "5":
        new_price = raw_input("Podaj nowa cene: ")
        new_price_update = ("UPDATE plants SET price WHERE price = ? " + new_price)
        self.cursor.execute(new_price_update)

    elif edit_fild == "6":
        new_availability = raw_input("Podaj nowa ilosc: ")
        new_availability_update = ("UPDATE plants SET availab WHERE availab = ? " + new_availability)
        self.cursor.execute(new_availability_update)

def Delete(self):
    delete_value = raw_input("Ktory rekord chcesz usunac?( podaj nazwe): ")
    delete_from_db = ("DELETE FROM plants WHERE name = ?", (delete_value))
    self.cursor.execute(delete_from_db)

def Add():
    print """
    Wypelnij ponizsze pola:
    ===============
    """
    name = raw_input("NAZWA: ")
    botanical = raw_input("NAZWA BOTANICZNA: ")
    localization = raw_input("LOKALIZACJA: ")
    light = raw_input("TYP OSWIETLENIA: ")
    price = raw_input("CENA: ")
    availab = raw_input("DOSTEPNOSC: ")

    add_to_db = ("INSERT INTO plants (common, botanical, localization light, price, availab) WHERE = ?", (name),(botanical),(localization),(light),(price),(availab))
    self.cursor.execute(add_to_db)

if name == 'main':
database_connection = DatabaseConnection()
database_connection.path(path_choice)
#database_connection.createtable()
database_connection.insertcommon()
database_connection.insertbotanical()
database_connection.insertzone()
database_connection.insertprice()
database_connection.insertavailability()
if database_connection.choice == "1":
database_connection.editinput()
database_connection.editdata()
elif database_connection.choice == "2":
database_connection.add()
elif database_connection.choice == "3":
database_connection.delete()
elif database_connection.ch2oice == "4":
database_connection.searchinput()
database_connection.searchdbname()
else:
print "unknown error"
'''python

Myślę że bardziej zwięzła forma i konkretne wyskakujące błędy (bo nie mamy twojego środowiska), szybciej sprowadzą do ciebie osoby chętne pomóc, aby odpowiedzieć :D.
Niestety (chyba) nikt na etat tutaj tego nie robi, więc ściana tekstu może odstraszyć :)

Problem jaki dostaję w tej chwili to:

database_connection.path(path_choice), path_choice was not defined

Mimo, że metodę path() definiuję jako @staticmethod i zmienna path_choice była wcześniej zdeklarowana jako input od usera.

Przepraszam za wcześniejszy brak komunikatu błędu.

Niestety... Ale to tak nie zadziała i zacznę od tego, dlaczego tak nie zadziała :) .

1. Wywołujesz metodę statyczną w głównej osi programu, która nie jest przypisana do żadnej klasy, co niestety wyrzuci ci błędem gdy już zlikwidujesz błąd path_choice. Więc polecałbym z miejsca wyrzucić ten dekorator. Niestety on działa wyłącznie jak domknięcie wewnętrznej funkcji w tym przypadku.
2. Zmienna wewnątrz funkcji path, nawet jeśli zostanie zainicjalizowana, będzie ona tylko przypisana na potrzeby tej funkcji, nie będzie ona widoczna w osi programu. Przeanalizuj sobie dokładnie krok po kroku komunikaty tego krótkiego kodu:

@staticmethod
def func():
    var = "abc" #Tu nigdy program nie dochodzi, a według tego co zrozumiałem z twojego problemu, powinien zacząć.
    print("func") #Jak wyżej. 

ot = 'abc'

if __name__ == "__main__":
    print("main") #main
    print(dir()) #['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'func', 'ot'] 
    print(type(func)) #<class 'staticmethod'>
    print(func) # <staticmethod object at 0x7fbe6b9e7a20>
    try:
        func()
    except TypeError as ex:
        print(ex) #'staticmethod' object is not callable
    try:
        print(var)
    except NameError as ex:
        print(ex) #name 'var' is not defined
    print(ot) #abc

Metoda func staje się w teorii zadeklarowaną metodą, ale nie można się do niej odwołać. Więc jedyny sposób jaki tu widzę, to jeśli faktycznie wywołuje ci input usera (chyba że jest jako input przy odpalaniu programu np. z linii komend, to potrzebna lekka modyfikacja z sys.argv.)

def path(): #Bez dekoratora staticmethod
    (...)
    return choice_path
(...)

if __name__=="__main__":
    path_choice = path()
    database_connection = DatabaseConnection()
    database_connection.path(path_choice)

Chyba że źle rozumiem naturę problemu :).
Oczywiście, jeśli zmienną w jakiś sposób definiujesz wcześniej - a z kodu to nie wynika. Upewnij się że na pewno jest zdeklarowana.
Bo funkcje które są umieszczone przed if __name__ == "__main__": nie są wywoływane, są tylko wczytywane, po to, aby móc je wywołać. Czy zmienna path_choice jest na pewno zdeklarowana, właśnie możesz to sprawdzić za pomocą pustego wywołania metody dir() tak jak w przykładzie który napisałem troszkę wyżej :).

@Edit: Jakbym zostawił jakiś błąd w tekście, to srry. Poprawiłem już część, bo piszę z telefonu.
Jeśli coś przeoczyłem, albo to nie rozwiąże problemu, wrzuć dokładny zrzut errora, będziemy myśleć dalej :)

@Guaz Wielkie dzięki! Jak na taki elaborat nie spodziewałbym się że to z telefonu :D Przez weekend zmodyfikuję kod w oparciu o to co napisałeś i wrzucę update. Jeszcze raz dzięki! :)