Unterschiedliche Importe

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Schönen guten Tag,

Ich hätte eine frage zum importieren und zwar habe Ich zwei Datein "Hauptdatei","Nebendatei" ( die name sind nur Beispiele).


Als Ich an meinem "Arbeitsrechner" mit den Datein gearbeitet habe konnte Ich in der Hauptdatei sagen:

Code: Alles auswählen

from Nebendatei import nebenfunktion
das hat dann auch alles funktioniert.

Zuhause funktioniert das leider nicht mehr er findet die Datei ( die sich im gleichen Ordner befindet jedoch kann ich nicht auf die Funktion zugreifen)


Wenn Ich jedoch sage ( zu Hause):

Code: Alles auswählen

import Nebendatei

und dann an der Stelle wo Ich die Funktion benötige in der Hauptdatei:

Code: Alles auswählen

Nebendatei.nebenfunktion()
funktioniert alles wieder


Wieso ist das so und wo ist bei den beiden Arten der genaue unterschied beim Importieren ?

Ich danke euch.
Eine Vision ohne Aktion bleibe eine Illusion
Nach oben
Benutzeravatar
__blackjack__
User
Beiträge: 14053
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:
Kontaktdaten von __blackjack__

Das kann nicht sein. Bitte mal tatsächlichen Code zeigen der das Problem aufzeigt.
“Vir, intelligence has nothing to do with politics!” — Londo Mollari
Nach oben
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ich danke dir erstmal für die schnelle Antwort mich wundert es ehrlich gesagt auch.... da Ich im Internet überall gelesen habe das beides funktionieren sollte.

Also die Ordnerstruktur ist wie folgt: C:\Users\Marcel\PycharmProjects\NEU_Klimareport_Dieter-fertig -> in NEU_Klimareport_Dieter-fertig liegen alle Datein.


1 Datei: module_klimareport

Code: Alles auswählen

from pathlib import Path
import numpy as np
import pandas as pd
import shutil
import timeit
# Einstellungen für Pandas:
# pd.set_option('display.max_rows', None)
# pd.set_option('display.max_columns', None)
# pd.set_option('display.width', None)
# pd.set_option('display.max_colwidth', -1)
# pd.set_option('mode.chained_assignment', None)  # Schaltet SettingWithCopyWarning aus

fertigdaten = Path(r"C:\Users\Marcel\Desktop\Fertigdaten\Fertigdaten_2020_04.wrt")

speicherpfad = Path(r"C:\Users\Marcel\Desktop\Dummy Datein\Ausgewerte_Daten")

KANALNUMMER = {
    "DATUM": 0,
    "LUFTTEMPERATUR": 3,
    "RELATIVE_LUFTFEUCHTIGKEIT": 289,
    "MAX_TEMPERATUR": 249,
    "MIN_TEMPERATUR": 248,
    "NIEDERSCHLAG": 261,
    "SONNENSCHEINDAUER": 18,
    "MAX_WIND": 139,
    "WINDRICHTUNG": 73,
}
INTERVALLE = {
    "TAG": "D",
    "Uhrzeit_1": "06:00:00",
    "Uhrzeit_2": "06:50:00",
    "Uhrzeit_3": "13:50:00",
    "Uhrzeit_4": "20:50:00",
    "Uhrzeit_5": "23:59:00",
}
MONATE = {
    1: "Januar",
    2: "Februar",
    3: "März",
    4: "April",
    5: "Mai",
    6: "Juni",
    7: "Juli",
    8: "August",
    9: "September",
    10: "Oktober",
    11: "November",
    12: "Dezember"
}
UMRECHNUNGSFAKTOR = 3600


def daten_einlesen(pfad_fertigdaten):
    """
    -Die Daten werden eingelesen
    -Das Datum der Datei wird als Index festgelegt
    """

    datensatz = pd.read_csv(
        pfad_fertigdaten,
        sep="|",
        header=None,
        parse_dates=True,
        low_memory=False,
        na_values="******",
        usecols=[*KANALNUMMER.values()]  # Holt sich die Spaltenzahlen aus dem Dictonary
    )
    datensatz[0] = pd.to_datetime(datensatz[0])
    datensatz = datensatz.set_index(0)  # Datum wird Index
    datensatz = datensatz.fillna(int(-1))
    return datensatz


def datum_fuer_excel(ausgelesene_daten):
    """
    Aus dem Index der ausgelesenene_daten wird das jahr sowie der Monat extrahiert
    """

    anfangs_index = ausgelesene_daten.index.tolist()[0]
    jahr = str(anfangs_index).split("-")[0]
    monat = int(str(anfangs_index).split("-")[1])  # damit aus 04->4 wird
    monat_als_wort = MONATE.get(monat)
    return jahr, monat_als_wort, monat


def winddaten_erhalten(ausgelesene_daten):
    """
    -Aus dem übergebenen Datensatz werden die KANÄLE WINDRICHTUNG & MAX_WIND extrahiert
    -Danach werden wird für jedenTag der höchste MAX_Wind ermittelt und in abhängigkeit die dazugehörige WINDRICHTUNG
    -Am Ende werden die Values mit -1 zu einem leeren string gewandelt
    """

    winddaten = ausgelesene_daten[[KANALNUMMER.get("WINDRICHTUNG"), KANALNUMMER.get("MAX_WIND")]]
    winddaten = winddaten.loc[winddaten.groupby(pd.Grouper(freq="D")).idxmax().iloc[:, 1]]
    winddaten = winddaten.replace(-1, "******")
    return winddaten


def daten_mit_anderen_zeitindex(ausgelesene_daten, kanalnummer, intervall):
    """
    Wir extrahieren die übergebene kanalnummer aus dem übergebenen Datensatz,danach erstellen wir einen neuen Index
    in abhängigkeit von dem Übergebenen intervall und legen diesen über die extrahierten_daten.
    Beispiel:
    Wir übergebenen Uhrzeit_2 = "06:50:00" dann sieht unsere Series am Ende wie folgt aus
    2020-04-01 06:50:00    1.56
    2020-04-02 06:50:00    5.02
    2020-04-03 06:50:00    5.95
    ...
    """

    extrahierte_daten = ausgelesene_daten[kanalnummer]
    extrahierte_daten = pd.to_numeric(extrahierte_daten, errors='coerce').astype(
        "float")  # leer strings führen zu fehlern
    neuer_index = extrahierte_daten.index.indexer_at_time(time=intervall)
    extrahierte_daten_mit_neuem_index = pd.Series(extrahierte_daten.iloc[neuer_index], dtype=float)
    extrahierte_daten_mit_neuem_index = extrahierte_daten_mit_neuem_index.replace(-1, "******")
    return extrahierte_daten_mit_neuem_index


def sonnenschein_erhalten(ausgelesene_daten):
    """Aus dem Datensatz wird die Spalte mit der SONNENSCHEINDAUER extrahiert diese sind jedoch in Sekunden daher wird
     die Tagessumme ermittelt und diese durch den Umrechnungswert dividiert um die Tagessumme in Stunden zu erhalten
     """

    sonnenschein = ausgelesene_daten[KANALNUMMER.get("SONNENSCHEINDAUER")]
    sonnenschein = sonnenschein.replace(to_replace=-1, value=np.nan)
    sonnenschein = sonnenschein.groupby(pd.Grouper(freq=INTERVALLE.get("TAG"))).sum(
        min_count=1)  # mindestens 1 nicht nan value
    sonnenschein = sonnenschein.div(UMRECHNUNGSFAKTOR)
    sonnenschein = sonnenschein.replace(np.nan, "******")  # wenn ergebnis 0 wäre -> ungültig
    return sonnenschein


def daten_zusammenfassen(winddaten, luft_temp0650, luft_temp1350, luft_temp2050, relativ_luftfeucht0650,
                         relativ_luftfeucht1350, relativ_luftfeucht2050, max_temp, min_temp, sonnenschein,
                         niederschlag):
    """
    Die Daten werden in mehreren Datenframes zusammengefasst damit diese nachher einzeln in die Excel Datei
    geschrieben werden können ( es befinden sich dort Spalten mit Formeln -> ein großer Datenframe würde da nur stören
    """

    wert1 = winddaten.reset_index(drop=True)
    wert2 = luft_temp0650.reset_index(drop=True)
    wert3 = luft_temp1350.reset_index(drop=True)
    wert4 = luft_temp2050.reset_index(drop=True)

    wert6 = relativ_luftfeucht0650.reset_index(drop=True)
    wert7 = relativ_luftfeucht1350.reset_index(drop=True)
    wert8 = relativ_luftfeucht2050.reset_index(drop=True)

    wert10 = max_temp.reset_index(drop=True)
    wert11 = min_temp.reset_index(drop=True)
    wert12 = sonnenschein.reset_index(drop=True)
    wert13 = niederschlag.reset_index(drop=True)

    zusammengefasste_daten1 = pd.concat([wert1, wert2, wert3, wert4], axis=1)
    zusammengefasste_daten2 = pd.concat([wert6, wert7, wert8], axis=1)
    zusammengefasste_daten3 = pd.concat([wert10, wert11, wert12, wert13], axis=1)

    return zusammengefasste_daten1, zusammengefasste_daten2, zusammengefasste_daten3


def ordner_datei_organisation(speicherpfad_pfad, jahr, monat):
    """
    Es wird geprüft ob der speicherpfad existiert wenn nicht wird ein Ordner anglegt,das gleiche wird mit einem
    Excel Ordner gemacht in dem die neuen Excel Datein gespeichert werden danach wird eine Kopie der Muster-Datei
    erstellt in,danach wird die neu erstellt Datei mit dem Jahr und Monat benannt und zurückgegeben ( der Pfad)
    damit zum Schluss die Daten in diese Datei geschrieben werden.
    """

    datei_name = ("Klimareport_" + str(jahr) + "_" + str(monat) + ".xlsx")
    excel_ordner = speicherpfad_pfad.joinpath("Excel_Dateien")
    if not excel_ordner.exists():
        excel_ordner.mkdir()
    if excel_ordner.joinpath(datei_name).exists():
        excel_ordner.joinpath(datei_name).unlink()  # löscht vorhandene Datei in excel Ordner
    if speicherpfad_pfad.joinpath(datei_name).exists():
        speicherpfad_pfad.joinpath(datei_name).unlink()  # löscht vorhandene datei im Auswertungsordner
    muster_original = speicherpfad_pfad.joinpath("Muster Klimazettel MAT.xlsx")
    exceldatei = speicherpfad_pfad.joinpath(datei_name)
    shutil.copy(muster_original, exceldatei)
    return exceldatei, excel_ordner


def daten_in_excel(exceldatei, excelordner, zfg_daten1, zfg_daten2, zfg_daten3, jahr, monat_als_wort):
    """
    HINWEIS  writer.sheets = {sheet.title: sheet for sheet in writer.book} sorgt dafür das die Daten in einer Arbeits
    mappen angehängt da sonst immer eine neue Arbeitsmappe erstellt wird.

    Die übergebenen Daten werden in 3 Teile aufgesteilt damit diese vorhandene Formeln in der Excel Datei behindern
    """

    df1 = zfg_daten1.iloc[:10]
    df1_1 = zfg_daten1.iloc[10:20]
    df1_2 = zfg_daten1.iloc[20:]

    df2 = zfg_daten2.iloc[:10]
    df2_1 = zfg_daten2.iloc[10:20]
    df2_2 = zfg_daten2.iloc[20:]

    df3 = zfg_daten3.iloc[:10]
    df3_1 = zfg_daten3.iloc[10:20]
    df3_2 = zfg_daten3.iloc[20:]

    datum = pd.Series([jahr])
    monat = pd.Series([monat_als_wort])

    with pd.ExcelWriter(exceldatei, engine="openpyxl", mode="a") as writer:
        writer.sheets = {sheet.title: sheet for sheet in writer.book}
        datum.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=1, startcol=13)
        monat.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=1, startcol=11)
        df1.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=8, startcol=1)
        df1_1.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=19, startcol=1)
        df1_2.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=30, startcol=1)
        df2.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=8, startcol=7)
        df2_1.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=19, startcol=7)
        df2_2.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=30, startcol=7)
        df3.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=8, startcol=11)
        df3_1.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=19, startcol=11)
        df3_2.to_excel(writer, sheet_name="Klimareport_MAT", header=None, index=None, startrow=30, startcol=11)

    shutil.move(str(exceldatei), excelordner)  # shutil.move arbeitet nicht mit path object sondern mit str
    return exceldatei


def main(fertigdaten_pfad, speicherpfad_pfad):


    ausgelesene_daten = daten_einlesen(fertigdaten_pfad)

    jahr, monat_als_wort, monat = datum_fuer_excel(ausgelesene_daten)

    winddaten = winddaten_erhalten(ausgelesene_daten)

    luft_temp0650 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                KANALNUMMER.get("LUFTTEMPERATUR"),
                                                INTERVALLE.get("Uhrzeit_2"))

    luft_temp1350 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                KANALNUMMER.get("LUFTTEMPERATUR"),
                                                INTERVALLE.get("Uhrzeit_3"))
    luft_temp2050 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                KANALNUMMER.get("LUFTTEMPERATUR"),
                                                INTERVALLE.get("Uhrzeit_4"))

    relativ_luftfeucht0650 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                         KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
                                                         INTERVALLE.get("Uhrzeit_2"))

    relativ_luftfeucht1350 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                         KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
                                                         INTERVALLE.get("Uhrzeit_3"))
    relativ_luftfeucht2050 = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                                         KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
                                                         INTERVALLE.get("Uhrzeit_4"))

    max_temp = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                           KANALNUMMER.get("MAX_TEMPERATUR"),
                                           INTERVALLE.get("Uhrzeit_1"))
    min_temp = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                           KANALNUMMER.get("MAX_TEMPERATUR"),
                                           INTERVALLE.get("Uhrzeit_1"))

    sonnenschein = sonnenschein_erhalten(ausgelesene_daten)

    niederschlag = daten_mit_anderen_zeitindex(ausgelesene_daten,
                                               KANALNUMMER.get("NIEDERSCHLAG"),
                                               INTERVALLE.get("Uhrzeit_5"))
    # zfg = zusammengefasste
    zfg_daten1, zfg_daten2, zfg_daten3 = daten_zusammenfassen(winddaten, luft_temp0650, luft_temp1350, luft_temp2050,
                                                              relativ_luftfeucht0650, relativ_luftfeucht1350,
                                                              relativ_luftfeucht2050, max_temp, min_temp, sonnenschein,
                                                              niederschlag)

    exceldatei, excelordner = ordner_datei_organisation(speicherpfad_pfad, jahr, monat)

    exceldatei = daten_in_excel(exceldatei, excelordner, zfg_daten1, zfg_daten2, zfg_daten3, jahr, monat_als_wort)


    return exceldatei


if __name__ == "__main__":
    main(fertigdaten, speicherpfad)
2 Datei : module_pdf

Code: Alles auswählen

from win32com import client
from pathlib import Path
import os
import shutil
import sys

def pdf_umwandlung(excel_datei):

	if not excel_datei == "":
		o = client.Dispatch("Excel.Application")
		o.Visible = False
		wb_path =excel_datei
		wb = o.Workbooks.Open(wb_path)
		ws_index_list = [1] #welches Arbeitsblatt gedruckt werden soll
		path_to_pdf = excel_datei.replace(".xlsx",".pdf")
		wb.WorkSheets(ws_index_list).Select()
		wb.ActiveSheet.ExportAsFixedFormat(0, path_to_pdf)
		shutil.move(path_to_pdf,r"C:\Users\Marcel\Desktop\Dummy Datein\PDF")
		wb.Close(False)


3. Hauptdatei: gui

Code: Alles auswählen

import sys
from functools import partial
from pathlib import Path
from PyQt5.QtWidgets import QWidget, QApplication, QMessageBox, QFileDialog
from PyQt5.QtCore import pyqtSignal,pyqtSlot,QThread
from PyQt5 import uic

from time import sleep

#Benötige Datein

import module_klimareport
import module_pdf





class PROGRESS_THREAD(QThread):
    """Progressschleife run ist eine virtuelle funktion von QThred und darf vom Namen nicht verändert werden
    wir weißen am anfang den wert 0 zu und lassen diesen durch eine while schleife laufen die 0.1 sekunden sind so
    gewählt das es ca 10 sekunden entspricht da solange ca die Hauptdatei benötigt damit die Progressbar nicht auf 100
    % stehen bleibt wird diese am ende wieder auf 0 gesetzt"""

    progress_wert_aendern = pyqtSignal(int)

    def run(self):
        wert = 0
        while wert < 100:
            wert += 1
            sleep(0.001)
            self.progress_wert_aendern.emit(wert)
        if wert >= 100:
            wert = 0
            self.progress_wert_aendern.emit(wert)





class Gui(QWidget):


    fertigdatei_pfad = Path(r"C:\Users\Marcel\Desktop\Fertigdaten")
    speicher_pfad = Path(r"C:\Users\Marcel\Desktop\Dummy Datein\Ausgewerte_Daten")

    def __init__(self):
        super().__init__()
        self.UI_DATEI = uic.loadUi(r"C:\Users\Marcel\PycharmProjects\NEU_Klimareport_Dieter-fertig\gui.ui",self)
        self.initUI()
        self.show()

    def initUI(self):
        self.pfad_nicht_vorhanden()
        self.slots()


    def pfad_nicht_vorhanden(self):
        """prüft ob der default speicherpfad vorhanden ist"""
        if not self.speicher_pfad.exists():
            self.msg = QMessageBox()
            self.msg.setIcon(QMessageBox.Information)
            self.msg.setText("Der angegebene Pfad" + str(self.speicher_pfad) + " ist nicht vorhanden!")
            self.msg.setWindowTitle("Information")
            self.msg.show()


    def slots(self):
        """Hier werden aktionen "Slotmethoden" zugeordnet"""
        self.UI_DATEI.Dateipfad.mouseDoubleClickEvent = self.fertigdaten_interaktion
        self.UI_DATEI.Speicherpfad.mouseDoubleClickEvent = self.speicherpfad_interaktion
        self.UI_DATEI.startknopf.clicked.connect(self.starte_progressbar)
        self.UI_DATEI.startknopf.clicked.connect(self.skript_start)



    #Slot Methoden:
    def fertigdaten_interaktion(self, event):
        """Steuerung des Filedialog für den Fertigdateipfad der Rückgabewert wird dem Klassen attribute fertigdateipfad
        zugeordnen,ruft am ende die start methode auf um zu prüfen ob der startknopf freigegeben werden kann"""
        options = QFileDialog.Options()
        options |= QFileDialog.DontUseNativeDialog
        ausgewaehlter_pfad = QFileDialog.getOpenFileName(self, "Öffnen", directory=str(self.fertigdatei_pfad),
                                                  filter="*.wrt;;All Files(*)", options=options)
        self.UI_DATEI.Dateipfad.setText(ausgewaehlter_pfad[0])
        self.fertigdatei_pfad = Path(str(ausgewaehlter_pfad[0]))
        self.UI_DATEI.setFocus()
        self.startknopf_freigeben()

    def speicherpfad_interaktion(self,event):
        """Steuerung des Filedialog für den Speicherpfad der Rückgabewert wird dem Klassen attribute speicherpfad
        zugeordnen,ruft am ende die start methode auf um zu prüfen ob der startknopf freigegeben werden kann"""
        options = QFileDialog.Options()
        options |= QFileDialog.DontUseNativeDialog
        ausgewaehlter_pfad = QFileDialog.getExistingDirectory(options=options, directory=str(self.speicher_pfad))
        self.UI_DATEI.Speicherpfad.setText(ausgewaehlter_pfad)
        self.speicher_pfad = Path(str(ausgewaehlter_pfad))
        self.UI_DATEI.Speicherpfad.setEnabled(False)
        self.UI_DATEI.checkBox_speicherpfad.setChecked(False)
        self.UI_DATEI.setFocus()
        self.startknopf_freigeben()

    def startknopf_freigeben(self):
        """Prüft ob der Text der sich in den QTexteditfenster befindet kein leerer String ist und prüft ob die
        ausgewählten Pfade exestieren existieren -> wenn die Bedingungen erfüllt sind wird der startknopf freigegeben"""
        if self.UI_DATEI.Speicherpfad.text() and self.UI_DATEI.Dateipfad.text() != "":
            if self.fertigdatei_pfad.exists() and self.speicher_pfad.exists():
                self.UI_DATEI.startknopf.setEnabled(True)
        else:
            self.UI_DATEI.startknopf.setEnabled(False)


    def starte_progressbar(self):
        """Startet den Thread"""
        self.thread = PROGRESS_THREAD()
        self.thread.progress_wert_aendern.connect(self.progress_wert_setzen)
        self.thread.start()

    def progress_wert_setzen(self, wert):
        """wert wird druch das Threadsignal progress_wert_ändern aus der while schleife übergeben"""
        self.UI_DATEI.progressBar.setValue(wert)



    def skript_start(self):

            self.UI_DATEI.PDF_Radio_Button.setEnabled(False)
            self.UI_DATEI.Speicherpfad.setEnabled(False)
            self.UI_DATEI.Dateipfad.setEnabled(False)
            erzeugte_datei = module_klimareport.main(self.fertigdatei_pfad,self.speicher_pfad,)
            self.UI_DATEI.Meldungsfenster.setText(str(erzeugte_datei)+"wurde erzeugt!")
            # if self.UI_DATEI.PDF_Radio_Button.isChecked():
            #     module_pdf.pdf_umwandlung(str(erzeugte_datei))
            # print("PDF wurde erzeugt")
            self.UI_DATEI.PDF_Radio_Button.setEnabled(True)
            self.UI_DATEI.Speicherpfad.setEnabled(True)
            self.UI_DATEI.Dateipfad.setEnabled(True)
            self.UI_DATEI.Dateipfad.clear()
            
            
if __name__=="__main__":
    app = QApplication(sys.argv)
    gui = Gui()
    sys.exit(app.exec_())

Also eigentlich ist es so das Ich aus der GUI wenn Start gedrückt wird Ich die Funktion main aus dem Module Klimareport augrufen möchte ( da dann die ganze Datei abgearbeitet wird und später die funktion pdf umwandlung aus der Modul Pdf Datei aufrufen möchte nur wie gesagt wenn Ich diese Funktionen direkt in der Datei expliziert importieren möchte geht das nicht ( Pycharm zeigt mir zumindest kein Vorschlag an was Pycharm auf dem Arbeitsrechner jedoch gemacht hat )
Eine Vision ohne Aktion bleibe eine Illusion
Nach oben
Benutzeravatar
__blackjack__
User
Beiträge: 14053
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:
Kontaktdaten von __blackjack__

@Bl3nder: Funktioniert das nicht oder glaubst Du nur dass das nicht funktioniert weil Deine IDE irgendwas nicht mitbekommt?
“Vir, intelligence has nothing to do with politics!” — Londo Mollari
Nach oben
Bl3nder
User
Beiträge: 139
Registriert: Freitag 3. Januar 2020, 17:07

Ehrlich gesagt habe Ich es angenommen jedoch habe Ich es nun obwohl Ich keinen Vorschlag erhalten habe importiert ( hätte er es wirklich nicht gefunden hätte Ich ja einen Importerror bekommen müssen ) dieses ist jedoch nicht gekommen es wurde alles normal abgearbeitet nur wieso kommt es zu diesem "Fehler" ?
Eine Vision ohne Aktion bleibe eine Illusion
Nach oben
Antworten

Zurück zu „Allgemeine Fragen“