Labeldruck und was draus folgt

[theoS]

Nope. Alles was mit LAN zu tun hat geht nicht.
Das hat nicht nur was mit wollen zu tun.
Firmennetzwerkparanoia.
Wie gesagt, das ist einfach gegeben.

[theoS]

Bin ich mal wieder blind, oder warum sehe ich nicht, warum das nicht funktioniert. Ich habe folgenden Code zusammengeschustert:

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path
import pyudev


pfat = Path('/media/earl/')
print(pfat)
context = pyudev.Context()

monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by('block')
for device in iter(monitor.poll, None):
    if 'ID_FS_TYPE' in device: ###
        print('{0} partition {1}'.format(device.action, device.get('ID_FS_LABEL')))### 
        print(device.action)
        if device.action == 'add':
            print("drin")
            name_of_stick = device.get('ID_FS_LABEL')
            print(name_of_stick)
            pfad_Sti = Path(pfat, name_of_stick, 'Text.txt')
            print(pfad_Sti)
            outfile = open(Path(pfad_Sti),'r')
            print(outfile.read())

das gibt folgende Fehlermeldung:

add
drin
OLEBIRD
/media/earl/OLEBIRD/Text.txt
Traceback (most recent call last):
File "/home/earl/projekt/USB/usb.V.py", line 29, in <module>
outfile = open(Path(pfad_Sti),'r')
FileNotFoundError: [Errno 2] No such file or directory: '/media/earl/OLEBIRD/Text.txt'

Wenn ich auf der Konsole das hier eingeben:

Code: Alles auswählen

>>> out = open('/media/earl/OLEBIRD/Text.txt')
>>> print(outfile.read())

bekomme ich das Ergebnis:

Alle meine Entchen

Der Pfad wird doch korrekt ausgelesen, die Datei ist genauso da wie beim zweiten Mal. Aber, auch wenn ich hier den Pfad in den open()-Teil hart codiere, krieg ich die Fehlermeldung.
Der Stick ist gemountet und man kann drauf zugreifen und alles.
Woran kann das liegen? Ist das wieder so ein Einrück-Trick?
Danke.

[theoS]

Code: Alles auswählen

Hab gerade gesehen, dass ich oben mal wieder einen Kopierfehler gemach hab. War schon spät..
Zudem viele Tipps bisher nicht beherzigt - zumindest in dem Teil den ich da reinkopiert hab.
Ich hab das jetzt so, und es funktioniert immer noch nicht.

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path
import pyudev


MEDIA_PFAD: Path = Path('/media/earl/')
datei_name: Path = Path('Text.txt')
print(MEDIA_PFAD)
context = pyudev.Context()
def usb_ansteckerkenner():
    monitor = pyudev.Monitor.from_netlink(context)
    monitor.filter_by('block')
    for device in iter(monitor.poll, None):
        if 'ID_FS_TYPE' in device: ###
            print('{0} partition {1}'.format(device.action, device.get('ID_FS_LABEL')))### 
            print(device.action)
            if device.action == 'add':
                print("drin")
                name_of_stick: Path = Path(device.get('ID_FS_LABEL'))
                print(name_of_stick)
                datei_leser(name_of_stick)
           
def datei_leser(nos):
    pfad_stick: Path = Path(MEDIA_PFAD / nos / datei_name)
    print(pfad_stick)
    with pfad_stick.open(encoding="utf-8") as outfile:
        print(outfile.read())

def main():
    usb_ansteckerkenner()
    

if __name__ == "__main__":
    main()        

Das gibt in spyder die Fehlermeldung:

runfile('/home/earl/projekt/USB/usb.Vxx1.py', wdir='/home/earl/projekt/USB')
/media/earl
remove partition OLEBIRD
remove
add partition OLEBIRD
add
drin
OLEBIRD
/media/earl/OLEBIRD/Text.txt
Traceback (most recent call last):

File "<ipython-input-1-1f4dc29d8e3f>", line 1, in <module>
runfile('/home/earl/projekt/USB/usb.Vxx1.py', wdir='/home/earl/projekt/USB')

File "/usr/lib/python3/dist-packages/spyder/utils/site/sitecustomize.py", line 705, in runfile
execfile(filename, namespace)

File "/usr/lib/python3/dist-packages/spyder/utils/site/sitecustomize.py", line 102, in execfile
exec(compile(f.read(), filename, 'exec'), namespace)

File "/home/earl/projekt/USB/usb.Vxx1.py", line 36, in <module>
main()

File "/home/earl/projekt/USB/usb.Vxx1.py", line 32, in main
usb_ansteckerkenner()

File "/home/earl/projekt/USB/usb.Vxx1.py", line 23, in usb_ansteckerkenner
datei_leser(name_of_stick)

File "/home/earl/projekt/USB/usb.Vxx1.py", line 28, in datei_leser
with pfad_stick.open(encoding="utf-8") as outfile:

File "/usr/lib/python3.6/pathlib.py", line 1183, in open
opener=self._opener)

File "/usr/lib/python3.6/pathlib.py", line 1037, in _opener
return self._accessor.open(self, flags, mode)

File "/usr/lib/python3.6/pathlib.py", line 387, in wrapped
return strfunc(str(pathobj), *args)

FileNotFoundError: [Errno 2] No such file or directory: '/media/earl/OLEBIRD/Text.txt'

wobei ja letztere Zeile das aussagt, was eben dieser Schnipsel Code (diesmal mit richtigerer Schreibweise) nicht so aussagt.

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path

MEDIA_PFAD: Path = Path('/media/earl/')
datei_name: Path = Path('Text.txt')
nos: Path = Path('OLEBIRD')
print(MEDIA_PFAD)
pfad_stick: Path = Path(MEDIA_PFAD / nos / datei_name)
print(pfad_stick)
with pfad_stick.open(encoding="utf-8") as outfile:
   print(outfile.read())
   outfile.close

Ergibt dann den Output:

runfile('/home/earl/projekt/USB/usb.raw.py', wdir='/home/earl/projekt/USB')
/media/earl
/media/earl/OLEBIRD/Text.txt
Alle meine Entchen

Sprich, alles was in der Datei drin steht.

Kann es sein, dass Python hier schneller als mount ist?
Der Code wird ja im Prinzip genau dann ausgeführt wenn der Stick eingesteckt ist. Allerdings hat er dann ja schon einen Namen, sprich, der Mountpoint ist schon da,. müsste dann auch drauf zugreifen können.

(Diese merkwürdige Schreibweise für die Path-Variablen hab ich von hier: https://www.btelligent.com/blog/best-pr ... en-teil-2/
wollte das mal ausprobieren, bringt diese Schreibweise irgendeinen Vorteil?
Denke dass

Code: Alles auswählen

MEDIA_PFAD: Path = Path('/media/earl/') 

das gleiche ist wie

Code: Alles auswählen

MEDIA_PFAD = Path('/media/earl/') 

oder ist da ein Unterschied??)

Danke.

[__deets__]

Es kann sein, dass das Ereignis vor dem Mount kommt, denn wenn die Namen aussagekräftig sind, dann reagierst du ja auf das erscheinen einer Partition. Und damit auf das gleiche Ereignis, dass erst das mount auslöst. Das mount mag also noch im Gange sein, denn es dauert auch länger. Ob die Namen nun wiederum aussagekräftig SIND - keine Ahnung. Eine Datei die du einliest heißt ja auch outfile

Und auch sonst gibt’s wieder viel anzumerken. Sinnlose close, einmal weil ohne Klammern, und dann weil with das doch schon macht. Path() um Path() ist auch unnötig. Konstanten mal groß, mal klein. Namen mal lang, mal kryptisch kurz, und das auch noch für das gleiche Ding. Alles sehr konfus und verwirrend.

[__blackjack__]

@theoS: Wenn Du Typannotationen nutzen willst, solltest Du unbedingt auch eine Software verwenden, welche diese Annotationen auswertet. Denn sonst können die falsch sein, ohne das Du es merkst, und damit das Gegenteil von dem bewirken wofür sie gedacht sind. Und bei den gezeigten Zuweisungen macht eine Annotation gar keinen Sinn weil ja gleich hinter dem ``=`` deutlich sichtbar ist welchen Typ das hat. Sowohl für Menschen, als auch für statische Typprüfungen. Bei Zuweisungen würde ich nur Typen annotieren wenn die Typprüfung die nicht von selbst heraus finden kann, oder wenn man explizit einen ”engeren” Typ annotieren möchte als der vom Wert der zugewiesen wird. Sonst ist das nur unnötige Tipparbeit.

Die Quelle ist übrigens nicht gut. Die behauptet allen ernstes ``path_file = os.sep.join([path_dir, filename])`` wäre der Weg (ohne/vor `pathlib`) um Pfadteile zusammen zu setzen. Nach welchem Kriterium der Autor dort Typen annotiert oder auch nicht, ist nicht ersichtlich, und die sind auch so weit ich das sehe alle nicht notwendig.

[theoS]

Es kann sein, dass das Ereignis vor dem Mount kommt, denn wenn die Namen aussagekräftig sind, dann reagierst du ja auf das erscheinen einer Partition. Und damit auf das gleiche Ereignis, dass erst das mount auslöst. Das mount mag also noch im Gange sein, denn es dauert auch länger.

Danke, das wars tatsächlich. Hab jetzt ein time.sleep(3) eingebaut, dann liest das Ding brav aus was in der Datei drin steht.

Die Pfade sollen ja noch variabel werden. Zum einen muss ich ja vom Stick lesen und auch drauf schreiben. Da werde ich mir, denke ich, eine Liste anlegen wo ich dann der Reihe nach abarbeite. Die lege ich dann doch geschickter in eine Variable. Drum ist das einmal GROSS und einmal klein. Wieder falsch?
Und ja, das mit dem .close ohne Klammer, war der Überrest der zig Versuche das hinzukriegen, dass die Datei gelesen wird und auch noch der Stick dann wieder freigegeben wird. Das hatte ich vorher ohne with gemacht, da half das komischerweise auch ohne Klammern. (an die Biester muss ich mich erst noch gewöhnen)

Wenn Du Typannotationen nutzen willst,

Will ich nicht. Hab ich jetzt mal so übernommen um das zu testen, ob das damit geht. Und weil ich nicht wusste, was das ist (Google gibt nicht so viel her, wenn man nach einem Doppelpunkt sucht ) hab ich gleich mitgefragt. Spare ich mir also, denn es geht ja mit dem sleep ganz fein.

Danke für die Hilfe!
Es geht weiter.

[__blackjack__]

@theoS: Das mit dem `sleep()` ist entweder nicht robust oder es dauert lange bis man merkt ob die Partition eingehängt wurde oder nicht. Sauber wäre es wahrscheinlich per D-Bus auf das einhängen zu warten sofern das geht.

[theoS]

@theoS: Das mit dem `sleep()` ist entweder nicht robust oder es dauert lange bis man merkt ob die Partition eingehängt wurde oder nicht. Sauber wäre es wahrscheinlich per D-Bus auf das einhängen zu warten sofern das geht.

Das stimmt schon. Aber ich denke, dass man die 3 Sekunden abwarten kann. Mit dem D-Bus weiß ich halt jetzt schon mal gar nicht wie umgehen und die Udev-Regel hat bei dem Pi auch schon nicht hingehaut. Zudem soll ja einfach jeder Stick der eingesteckt wird gechecket werden ob die Dateien drauf sind, dann zwangsweise ausgetauscht - als die vom Arbeitsverzeichnis auf den Stick, die vom Stick ins Arbeitsverzeichnis.
Im Zweifel soll maximal eine Meldung aufploppen die Erfolg oder Misserfolg ausdrückt. Ob ich zur "Pflege" die Button-Oberfläche kurz ausblende oder nicht hab ich noch nicht entschlossen.
Robust sollte das Ding ja möglichst schon sein. Hab keinen Bock da ständig dann vor Ort aufzutauchen bloß weil die zu doof sind einen Stick einzustecken. (Ja, da wär mir ein LAN, gleich welches auch lieber...)

[theoS]

Bin mal wieder einen Schritt weiter gekommen und habe mal was geschafft, was funktioniert.
Vermute zwar, dass ich das wieder sehr kompliziert gemacht hab, aber ich bin stolz drauf, dass das funktioniert!
Das ist ein Teil der Projekts, das ich dann noch in die "USB-Erkennung" mit einbauen muss. Daher habe ich den Namen des Sticks mal in eine Variable per Hand geschrieben. Der Name wird dann ja später von dem anderen Teil ermittelt.

Code: Alles auswählen

from datetime import datetime
from pathlib import Path

PFAD = Path.home() / ".DruckData"
MEDIA_PFAD = Path('/media/earl/')
name_of_stick = 'OLEBIRD'
DATEI_NAMEN = ['numbers.csv', 'TB_Ausgabe_8.txt']
###----------------------------------------------------

dateTimeObj = datetime.now()
timestampStr = dateTimeObj.strftime("%d%b%Y_%Hu%M")


def datei_auf_stick(name_of_stick, datei_name):
    datei_name = Path(datei_name)
    #print(datei_name)
    teil_name = datei_name.stem
    #print(teil_name)
    #print(datei_name.with_name( f"{teil_name}_{timestampStr}.csv"))
    copier_auf_stick = datei_name.with_name( f"{teil_name}_{timestampStr}.csv")
    pfad_ziel = Path(MEDIA_PFAD / name_of_stick / copier_auf_stick)
    #print(pfad_ziel)
    pfad_ursprung = Path(PFAD / datei_name)

    #print(pfad_ursprung)
 
    try:    
        with pfad_ursprung.open('r', encoding="utf-8") as urfile:
            
            inhalt_textfile = urfile.read()
            #print(inhalt_textfile)  #hier kommt noch eine Abfrage rein (Zeitstempel)
            with pfad_ziel.open('w', encoding="utf-8") as zielfile:
                zielfile.write(inhalt_textfile)

    except FileNotFoundError:
        print('war wohl nicht da der File')  
        
        
def datei_auf_arbeitsverzeichnis(name_of_stick, datei_name):
    datei_name = Path(datei_name)
    #print(datei_name)
    pfad_ursprung = Path(MEDIA_PFAD / name_of_stick / datei_name)
    #print(pfad_ursprung)
    pfad_ziel = Path(PFAD / datei_name)
    print(pfad_ziel)
    try:    
        with pfad_ursprung.open('r', encoding="utf-8") as urfile:
            
            inhalt_textfile = urfile.read()
            #print(inhalt_textfile)  
            with pfad_ziel.open('w', encoding="utf-8") as zielfile:
                zielfile.write(inhalt_textfile)

    except FileNotFoundError:
        print('war wohl nicht da der File')          
    
def main():
    for datei_name in DATEI_NAMEN:

        datei_auf_stick(name_of_stick, datei_name)
        datei_auf_arbeitsverzeichnis(name_of_stick, datei_name)

if __name__ == "__main__":
    main()        

[__blackjack__]

@theoS: Trotzdem ist die Variable für den Stick-Namen in diesem Code ja eine Konstante, deshalb sollte man die auch entsprechend in Grossbuchstaben benennen.

Während `timestampStr` nicht nur nicht den Namenskonventionen entspricht, sondern auch nicht auf Modulebene gehört, weil das keine Konstante ist.

Das Format selbst ist unglaublich bescheuert: "22Mar2020_16u07". WTF‽ Ich kann ja noch verstehen wenn Leute aus Gewohnheit das Datum als Tag.Monat.Jahr formatieren, aber das Format ist ja jenseits von allem was Sinn macht. Datums- und Zeitangaben sollte man immer im ISO-Format oder zumindest daran angelehnt formatieren, sofern es nicht um die reine Darstellung in einer lokalisierten Form für den Benutzer geht. Und wenn man von ISO 8601 abweicht, zum Beispiel weil Doppelpunkte in einem Dateinamen auf einigen Dateisystemen Probleme machen können, dann doch so, dass man die Vorteile nicht verliert. Zum Beispiel das so formatierte Datums- und Zeitangaben lexikografisch sortiert auch gleichzeitig zeitlich in der richtigen Reihenfolge sind.

Teile als Text zu formatieren hat übrigens noch den Nachteil, dass das von globalen Einstellungen beeinflusst werden kann. Wenn man nämlich die ”locale” vom System setzt, dann liefert das nicht mehr "22Mar2020_16u07" sondern "22Mär2020_16u07". Also zumindest für deutschsprachige ”locale”-Einstellungen.

Dateinamen ist im Deutschen *ein* Wort. Wobei man sich natürlich überlegen kann/sollte warum man mal deutsch- und mal englischsprachige Namen verwendet und wonach man eigentlich entscheidet wann man was nimmt.

`Path()` grundsätzlich mit einem `Path`-Objekt aufzurufen macht keinen Sinn. Da kommt nur das gleiche heraus was man auch hineingesteckt hat.

Beide Funktionen enthalten einen identischen Codeteil zum kopieren den man in eine eigene Funktion herausziehen sollte.

`copier_auf_stick` ist ein sehr seltsamer Name.

`Path`-Objekte haben jeweils eine Methode um den gesamten Inhalt einer Datei als Text oder Bytes auszulesen beziehungsweise zu schreiben. Wenn man den Textinhalt nicht zwischendurch ausgeben will, würde sich an der Stelle aber auch `shutil.copy()` aus der Standardbibliothek anbieten.

Aus den `print()`-Ausgaben würde ich Logging machen.

Ungetestet:

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import datetime as DateTime
from pathlib import Path

from loguru import logger

PFAD = Path.home() / ".DruckData"
MEDIA_PFAD = Path("/media/earl/")
NAME_OF_STICK = "OLEBIRD"
DATEINAMEN = ["numbers.csv", "TB_Ausgabe_8.txt"]


def copy(source_path, destination_path):
    logger.info("Copying {!r} to {!r}.", source_path, destination_path)
    try:
        text = source_path.read_text(encoding="utf-8")
        logger.debug(text)
        destination_path.write_text(text, encoding="utf-8")
    except FileNotFoundError as error:
        logger.error("File not found {}.", error)


def datei_auf_stick(name_of_stick, dateipfad, timestamp):
    copy(
        PFAD / dateipfad,
        MEDIA_PFAD
        / name_of_stick
        / dateipfad.with_name(
            f"{dateipfad.stem}_{timestamp:%Y-%m-%d_%H_%M}.csv"
        ),
    )


def datei_auf_arbeitsverzeichnis(name_of_stick, dateipfad):
    copy(MEDIA_PFAD / name_of_stick / dateipfad, PFAD / dateipfad)


@logger.catch()
def main():
    timestamp = DateTime.now()
    for dateiname in map(Path, DATEINAMEN):
        datei_auf_stick(NAME_OF_STICK, dateiname, timestamp)
        datei_auf_arbeitsverzeichnis(NAME_OF_STICK, dateiname)


if __name__ == "__main__":
    main()

[theoS]

@ __blackjack__
Danke fürs drüberschauen.
Das mit den Variablen und Konstanten ist ja alles noch nicht fix, da muss ich auch selbst noch eine Methode für mich finden, die mich nicht selbst verwirrt. Dass ich hier gemischt verwende liegt mehr oder weniger am Copy-Paste-Syndrom.

Während `timestampStr` nicht nur nicht den Namenskonventionen entspricht,

z.B. hab ich aus der Beschreibung von der Seite die ich am besten verstanden hab. Vermutlich nicht die Beste, aber bei den Besten habe ich oft das Problem das nachzuvollziehen.
Das mit dem timestamp war zudem, muss ich zugeben, eine Idee die sowieso in der Sackgasse verenden wird. Prinzipiell brauche ich nur irgendeinen Unterschied, der mir garantiert, dass ich die beiden Dateien nicht überschreibe. (Und ich mag das amerikanische Datumsformat so ganz und überhaupt nicht) Das hat seine Aufgabe so erfüllt, da überlege ich mir dann im endgültigen Code vielleicht einfach eine Nummer oder einen Buchstaben oder etwas anderes. Vielleicht nur die Uhrzeit, mal sehen.

Beide Funktionen enthalten einen identischen Codeteil zum kopieren den man in eine eigene Funktion herausziehen sollte.

Hatte ich mir schon überlegt, aber irgendwie nicht gesehen wie ich das anstellen soll. Wär so einfach gewesen.
Danke dafür.

Das mit dem logger hört sich interessant an, die print-Anweisungen habe ich bisher nur für mich drin gehabt, als "Platzhalter" dafür dass da noch was kommen muss wenn die Datei nicht gefunden wird. Dann soll der Code ja vielleicht eine Meldung ausgeben und sonst nichts mehr tun als aufzufordern dass die Dateien auf dem Stick sein müssen.
Wieder einen Schritt weiter.
danke

[Sirius3]

Amerikanisches Format ist mm/dd/yy, das ist wirklich gewöhnungsbedürftig. Aber yyyy-mm-dd ist einfach das praktischste, weil man es auch lexikalisch sortieren kann.

[__blackjack__]

@theoS: ISO 8601 ist eine internationale Norm, keine amerikanische. Falls Du lieber eine deutsche Norm haben möchtest nimm halt DIN ISO 8601 — macht inhaltlich keinen Unterschied. Eigentlich ist das über DIN 5008 in Deutschland auch für den Schriftverkehr beispielsweise mit Behörden vorgesehen, aber die Luschen haben da für das Inland die alte Schreibweise als Ausnahme gelassen.

[theoS]

aber die Luschen haben da für das Inland die alte Schreibweise als Ausnahme gelassen.

Ab so was von Gottseidank!
Ich (und nicht nur ich) kann das Datum so überhaupt nicht leiden, auch wenn das 100000mal eine internationale Norm ist. Letztlich kommt es von den amerikanischen Normen, drum ist das für mich das amerikanische Datum. Ich kann z.B. eine Datei auf diesem Weg »datumisiert« wunderhübsch sortieren, aber bis ich da einen Unterschied SEHE hab ich mir die Augen verkrampft. Und, auch das muss ich für mich in Anspruch nehmen: Die Maschine ist für mich da mir das Leben leichter zu machen, nicht ich der Maschine. Und grad beim Datum/Uhrzeit hinken die Systementwickler leider der Vielfalt in der Welt ziemlich hinterher.

Aber, darum geht es ja in meinem Projekt gar nicht.
Nochmal: Es war ein Mittel zum Zweck die Dateien nicht zu verwechseln und bei meinen Tests auch zu sehen, was der Code mit den Dateien macht. Das fällt dir/euch vielleicht leichter, das aus dem Code schon zu lesen, ich brauch da halt so was dazu.

[__blackjack__]

@theoS: Von welchem amerikanischen Normen fantasierst Du da? Wie Sirius3 bereits mit Beispiel geschrieben hat, ist das *nicht* das amerikanische Datumsformat! Das ist ein ISO-Standard, der mittlerweile wie sehr viele ISO-Standards auch einen DIN-Standard mit äquivalentem Inhalt hat. ISO = *International* Standards Organization.

Gerade wegen die Vielfalt der Welt was diese Schreibweisen angeht, gab es ja das bestreben für den leichteren Austausch ein internationales Format zu haben. Und dabei dann zu schauen welche Schreibweise(n) die sinnvollsten Eigenschaften hat. Auch was die maschinelle Verarbeitung angeht, aber die Eigenschaften machen auch für Menschen Sinn. Zum Beispiel das auf Eindeutigkeit geachtet wurde und das wie bei Zahlen die einzelnen Einheiten der Wertigkeit nach geordnet aufgeschrieben werden.

Was Du mit dem hinterherhinken der Systementwickler meinst, ist mir ehrlich gesagt nicht klar. Betriebssysteme bekommen das mit der Lokalisierung normalerweise gut hin, und es gibt auch für Entwickler von normalen Anwendungen Bibliotheken mit denen sich Datums- und Zeitangaben für andere „locales“ formatieren lassen.

[theoS]

Hab nun Zeit gehabt, den Code durchzuschauen. So ganz erschließt sich der Vorteil von map() für mich nicht. Hab gelesen, dass das elegant sein soll, aber den Vorteil daraus? Ist für mich eher verwirrend als logisch.
Aber egal, das funktioniert, und da es elegant sein soll, warum nicht? Wieder was neues kennengelernt.

Den Logger heb ich mir für später auf, der ist mir ein wenig zu redselig. Ich brauch ja nur immer das Zwischenergbnis für mich, dass ich weiß was der Code da tut.
Aber ich sehe schon, dass das noch nützlich werden kann...
Danke für die Tipps!
Den Teil des Codes habe ich nun in mein USB-Überwachungsteil eingebaut, das jetzt so wie ich es jetzt hab, die beiden Dateiinhalte austauscht, wie es das soll.
Gibt bestimmt was zu verbessern. )

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path
import pyudev
import time
import pathlib
from datetime import datetime as DateTime
###---------------------------------------------------
PFAD = Path.home() / ".DruckData"
##ABFRAGE_FILENAME = PFAD / "TB_Ausgabe_Abfrage8StueckII.txt"
##ZAEHLER_FILENAME = PFAD / "numbers.csv"
###----------------------------------------------------
MEDIA_PFAD = Path('/media/earl/')
WECHSEL_DATEI_NAMEN = ["numbers.csv", "TB_Ausgabe_8iii.txt"]
print(MEDIA_PFAD)
context = pyudev.Context()
def usb_ansteckerkenner():
    monitor = pyudev.Monitor.from_netlink(context)
    monitor.filter_by('block')
    for device in iter(monitor.poll, None):
        if 'ID_FS_TYPE' in device: ###
            
            print(device.action)
            if device.action == 'add':
                
                name_of_stick = Path(device.get('ID_FS_LABEL'))
                print(name_of_stick)
                time.sleep(2)
                
                return name_of_stick
           
####--------------------------------------------------------------------#####

def copy(source_path, destination_path):    
    try:
        text = source_path.read_text(encoding="utf-8")        
        destination_path.write_text(text, encoding="utf-8")
    except FileNotFoundError as error:
        print(error)
           
####--------------------------------------------------------------------#####

def datei_auf_stick(name_of_stick, dateipfad, timestamp):    
    copy(
        PFAD / dateipfad,
        MEDIA_PFAD
        / name_of_stick
        / dateipfad.with_name(
            f"{dateipfad.stem}_{timestamp:%Y-%m-%d_%H_%M}.csv"
        ),
    )
           
####--------------------------------------------------------------------#####

def datei_auf_arbeitsverzeichnis(name_of_stick, dateipfad):
    copy(MEDIA_PFAD / name_of_stick / dateipfad, PFAD / dateipfad)

           
####--------------------------------------------------------------------#####

def main():
    timestamp = DateTime.now()
    name_of_stick = usb_ansteckerkenner()
    
    for dateiname in map(Path, WECHSEL_DATEI_NAMEN):  
        datei_auf_stick(name_of_stick, dateiname, timestamp)
        datei_auf_arbeitsverzeichnis(name_of_stick, dateiname)
    

if __name__ == "__main__":
    main()        

Nächster Schritt: Fehlerabfangen...
Wenn die Datei nicht da ist, soll da eine kleine Box aufgehen, die knapp drüber informiert, dass da mit den Dateien was nicht passt.
Die Box soll über den Knöpfen des anderen Codeteils liegen und nichts anderes machen als den stick zu unmounten.
Grübel...

[Sirius3]

Da hat es jetzt noch so Zeilen mit vielen Minuszeichen, die den Lesefluß stören. Funktionen trennt man mit zwei Leerzeilen.

[theoS]

Danke, die kommen noch raus, das brauch ich im Moment noch um die Trennung zu sehen.
Bin schon ein alter Mann

[theoS]

Zum Auswerfen des Sticks kann ich so was verwenden.

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path
import subprocess

MEDIA_PFAD = Path("/media/earl/")
def main():
    vpath = MEDIA_PFAD  / "SEAGULL"
    print(vpath)
    cmd = 'umount ' + str(vpath)
    print(cmd)
    subprocess.Popen(str(cmd), shell=True, stdout=subprocess.PIPE)

if __name__ == "__main__":
    main() 

wobei mich da irritiert, dass ich das Path-Objekt in einen String umwandeln muss, aber das muss wohl so sein weil ich das ja an die Shell durchreiche.
Gibts da noch was besseres?

[__deets__]

Ja, subprocess ohne Shell=True und mit einer Liste statt einem String - dann muss auch kein path konvertiert werden.