ฉันจะดูไฟล์สำหรับการเปลี่ยนแปลงได้อย่างไร

ฉันมีไฟล์บันทึกที่เขียนโดยกระบวนการอื่นซึ่งฉันต้องการดูการเปลี่ยนแปลง ทุกครั้งที่มีการเปลี่ยนแปลงฉันต้องการอ่านข้อมูลใหม่เพื่อทำการประมวลผล

วิธีที่ดีที่สุดในการทำเช่นนี้คืออะไร? ฉันหวังว่าจะมีตะขอบางอย่างจากห้องสมุด PyWin32 ฉันพบwin32file.FindNextChangeNotificationฟังก์ชัน แต่ไม่รู้ว่าจะขอให้ดูไฟล์เฉพาะได้อย่างไร

หากใครทำอะไรแบบนี้ฉันจะขอบคุณจริง ๆ ที่ได้ยินว่า ...

[แก้ไข]ฉันควรจะบอกว่าฉันเป็นคนที่ไม่ต้องการการสำรวจ

[แก้ไข]คำสาป! ดูเหมือนว่าสิ่งนี้จะไม่ทำงานกับไดรฟ์เครือข่ายที่แมป ฉันคาดเดาว่า windows จะไม่ 'ได้ยิน' การอัปเดตใด ๆ กับไฟล์ในแบบเดียวกับบนดิสก์ในเครื่อง

คุณได้ดูเอกสารที่มีอยู่ในhttp://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html แล้วหรือยัง หากคุณต้องการให้ทำงานภายใต้ Windows เท่านั้นตัวอย่างที่ 2 น่าจะเป็นสิ่งที่คุณต้องการอย่างแน่นอน (หากคุณแลกเปลี่ยนพา ธ ของไดเรกทอรีด้วยไฟล์ที่คุณต้องการดู)

มิเช่นนั้นการสำรวจอาจเป็นตัวเลือกที่ไม่ขึ้นกับแพลตฟอร์มเท่านั้น

หมายเหตุ:ฉันไม่ได้ลองวิธีแก้ไขปัญหาใด ๆ เหล่านี้

คุณลองใช้Watchdogหรือไม่

Python API library และ shell Utilities เพื่อตรวจสอบเหตุการณ์ของระบบไฟล์

การตรวจสอบไดเรกทอรีทำได้ง่ายด้วย

• API ข้ามแพลตฟอร์ม
• เครื่องมือเชลล์เพื่อเรียกใช้คำสั่งเพื่อตอบสนองต่อการเปลี่ยนแปลงของไดเรกทอรี

เริ่มต้นอย่างรวดเร็วด้วยตัวอย่างง่ายๆในQuickstart ...

ถ้าการสำรวจดีพอสำหรับคุณฉันแค่เฝ้าดูว่าสถิติการ "แก้ไขเวลา" ของไฟล์เปลี่ยนไปหรือไม่ หากต้องการอ่าน:

os.stat(filename).st_mtime

(โปรดทราบว่าโซลูชันการเปลี่ยนแปลงเนทิฟ Windows ไม่สามารถใช้งานได้ในทุกสถานการณ์เช่นบนไดรฟ์เครือข่าย)

import os

class Monkey(object):
    def __init__(self):
        self._cached_stamp = 0
        self.filename = '/path/to/file'

    def ook(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...

หากคุณต้องการโซลูชั่นที่หลากหลายแล้วตรวจสอบQFileSystemWatcher นี่คือตัวอย่างรหัส (ไม่ผ่านการฆ่าเชื้อ):

from PyQt4 import QtCore

@QtCore.pyqtSlot(str)
def directory_changed(path):
    print('Directory Changed!!!')

@QtCore.pyqtSlot(str)
def file_changed(path):
    print('File Changed!!!')

fs_watcher = QtCore.QFileSystemWatcher(['/path/to/files_1', '/path/to/files_2', '/path/to/files_3'])

fs_watcher.connect(fs_watcher, QtCore.SIGNAL('directoryChanged(QString)'), directory_changed)
fs_watcher.connect(fs_watcher, QtCore.SIGNAL('fileChanged(QString)'), file_changed)

มันไม่ควรทำงานบน windows (อาจมี cygwin?) แต่สำหรับผู้ใช้ยูนิกซ์คุณควรใช้การเรียกระบบ "fcntl" นี่คือตัวอย่างใน Python ส่วนใหญ่เป็นรหัสเดียวกันถ้าคุณต้องการเขียนใน C (ชื่อฟังก์ชั่นเดียวกัน)

import time
import fcntl
import os
import signal

FNAME = "/HOME/TOTO/FILETOWATCH"

def handler(signum, frame):
    print "File %s modified" % (FNAME,)

signal.signal(signal.SIGIO, handler)
fd = os.open(FNAME,  os.O_RDONLY)
fcntl.fcntl(fd, fcntl.F_SETSIG, 0)
fcntl.fcntl(fd, fcntl.F_NOTIFY,
            fcntl.DN_MODIFY | fcntl.DN_CREATE | fcntl.DN_MULTISHOT)

while True:
    time.sleep(10000)

ตรวจสอบpyinotify

inotify แทนที่ dnotify (จากคำตอบก่อนหน้า) ใน linux ที่ใหม่กว่าและอนุญาตให้ระดับไฟล์มากกว่าการตรวจสอบระดับไดเรกทอรี

หลังจากการแฮ็คสคริปต์ของ Tim Golden เล็กน้อยฉันมีสิ่งต่อไปนี้ซึ่งทำงานได้ค่อนข้างดี:

import os

import win32file
import win32con

path_to_watch = "." # look at the current directory
file_to_watch = "test.txt" # look for changes to a file called test.txt

def ProcessNewData( newData ):
    print "Text added: %s"%newData

# Set up the bits we'll need for output
ACTIONS = {
  1 : "Created",
  2 : "Deleted",
  3 : "Updated",
  4 : "Renamed from something",
  5 : "Renamed to something"
}
FILE_LIST_DIRECTORY = 0x0001
hDir = win32file.CreateFile (
  path_to_watch,
  FILE_LIST_DIRECTORY,
  win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
  None,
  win32con.OPEN_EXISTING,
  win32con.FILE_FLAG_BACKUP_SEMANTICS,
  None
)

# Open the file we're interested in
a = open(file_to_watch, "r")

# Throw away any exising log data
a.read()

# Wait for new data and call ProcessNewData for each new chunk that's written
while 1:
  # Wait for a change to occur
  results = win32file.ReadDirectoryChangesW (
    hDir,
    1024,
    False,
    win32con.FILE_NOTIFY_CHANGE_LAST_WRITE,
    None,
    None
  )

  # For each change, check to see if it's updating the file we're interested in
  for action, file in results:
    full_filename = os.path.join (path_to_watch, file)
    #print file, ACTIONS.get (action, "Unknown")
    if file == file_to_watch:
        newText = a.read()
        if newText != "":
            ProcessNewData( newText )

มันอาจจะทำอย่างไรกับการตรวจสอบข้อผิดพลาดในการโหลดมากขึ้น แต่สำหรับการดูไฟล์บันทึกและทำการประมวลผลบางอย่างก่อนที่จะแยกมันออกไปที่หน้าจอ

ขอบคุณทุกคนสำหรับข้อมูลของคุณ - สิ่งดีๆ!

สำหรับการดูไฟล์เดียวที่มีการสำรวจและการอ้างอิงน้อยที่สุดนี่เป็นตัวอย่างที่สมบูรณ์แบบโดยอิงจากคำตอบจากDeestan (ด้านบน):

import os
import sys 
import time

class Watcher(object):
    running = True
    refresh_delay_secs = 1

    # Constructor
    def __init__(self, watch_file, call_func_on_change=None, *args, **kwargs):
        self._cached_stamp = 0
        self.filename = watch_file
        self.call_func_on_change = call_func_on_change
        self.args = args
        self.kwargs = kwargs

    # Look for changes
    def look(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...
            print('File changed')
            if self.call_func_on_change is not None:
                self.call_func_on_change(*self.args, **self.kwargs)

    # Keep watching in a loop        
    def watch(self):
        while self.running: 
            try: 
                # Look for changes
                time.sleep(self.refresh_delay_secs) 
                self.look() 
            except KeyboardInterrupt: 
                print('\nDone') 
                break 
            except FileNotFoundError:
                # Action on file not found
                pass
            except: 
                print('Unhandled error: %s' % sys.exc_info()[0])

# Call this function each time a change happens
def custom_action(text):
    print(text)

watch_file = 'my_file.txt'

# watcher = Watcher(watch_file)  # simple
watcher = Watcher(watch_file, custom_action, text='yes, changed')  # also call custom action function
watcher.watch()  # start the watch going

ตรวจสอบคำตอบของฉันกับคำถามที่คล้ายกัน คุณสามารถลองวนซ้ำเดียวกันใน Python หน้านี้แนะนำ:

import time

while 1:
    where = file.tell()
    line = file.readline()
    if not line:
        time.sleep(1)
        file.seek(where)
    else:
        print line, # already has newline

ยังเห็นคำถามที่หาง () ไฟล์ที่มีงูหลาม

ทางออกที่ง่ายที่สุดสำหรับฉันคือการใช้เครื่องมือเฝ้าระวังของ watchdog

จากhttps://pypi.python.org/pypi/watchdogตอนนี้ฉันมีกระบวนการที่ค้นหาไฟล์ sql ในไดเรกทอรีและดำเนินการถ้าจำเป็น

watchmedo shell-command \
--patterns="*.sql" \
--recursive \
--command='~/Desktop/load_files_into_mysql_database.sh' \
.

เนื่องจากคุณใช้ Python คุณสามารถเปิดไฟล์และอ่านบรรทัดต่อไปได้

f = open('file.log')

หากการอ่านบรรทัดไม่ว่างคุณจะดำเนินการ

line = f.readline()
if line:
    // Do what you want with the line

คุณอาจจะพลาดที่จะสามารถโทรออกได้ readline EOF ต่อไป มันจะส่งคืนสตริงว่างในกรณีนี้ และเมื่อสิ่งที่ผนวกเข้ากับล็อกไฟล์การอ่านจะดำเนินต่อจากที่หยุดตามที่คุณต้องการ

หากคุณกำลังมองหาโซลูชันที่ใช้งานกิจกรรมหรือห้องสมุดเฉพาะกรุณาระบุในคำถามของคุณ มิฉะนั้นฉันคิดว่าวิธีนี้ใช้ได้ดี

นี่เป็นเวอร์ชั่นย่อของรหัส Kender ที่ดูเหมือนจะทำแบบเดียวกันและไม่นำเข้าไฟล์ทั้งหมด:

# Check file for new data.

import time

f = open(r'c:\temp\test.txt', 'r')

while True:

    line = f.readline()
    if not line:
        time.sleep(1)
        print 'Nothing New'
    else:
        print 'Call Function: ', line

นี่คือการปรับเปลี่ยนสคริปต์ของ Tim Goldan ที่ทำงานในประเภท unix และเพิ่มตัวเฝ้าดูอย่างง่ายสำหรับการแก้ไขไฟล์โดยใช้ dict (file => time)

การใช้งาน: AnythingName.py path_to_dir_to_watch

#!/usr/bin/env python

import os, sys, time

def files_to_timestamp(path):
    files = [os.path.join(path, f) for f in os.listdir(path)]
    return dict ([(f, os.path.getmtime(f)) for f in files])

if __name__ == "__main__":

    path_to_watch = sys.argv[1]
    print('Watching {}..'.format(path_to_watch))

    before = files_to_timestamp(path_to_watch)

    while 1:
        time.sleep (2)
        after = files_to_timestamp(path_to_watch)

        added = [f for f in after.keys() if not f in before.keys()]
        removed = [f for f in before.keys() if not f in after.keys()]
        modified = []

        for f in before.keys():
            if not f in removed:
                if os.path.getmtime(f) != before.get(f):
                    modified.append(f)

        if added: print('Added: {}'.format(', '.join(added)))
        if removed: print('Removed: {}'.format(', '.join(removed)))
        if modified: print('Modified: {}'.format(', '.join(modified)))

        before = after

อย่างที่คุณเห็นในบทความของ Tim Goldenชี้โดยHorst Gutmannว่า WIN32 นั้นค่อนข้างซับซ้อนและเฝ้าดูไดเรกทอรีไม่ใช่ไฟล์เดียว

ฉันอยากจะแนะนำให้คุณดูในIronPythonซึ่งเป็นการนำไปปฏิบัติของ. NET ด้วย IronPython คุณสามารถใช้ฟังก์ชัน. NETทั้งหมดรวมถึง

System.IO.FileSystemWatcher

ซึ่งจัดการไฟล์เดียวด้วยส่วนต่อประสานที่ใช้งานง่าย

นี่เป็นตัวอย่างของการตรวจสอบไฟล์สำหรับการเปลี่ยนแปลง หนึ่งที่อาจไม่ใช่วิธีที่ดีที่สุดในการทำ แต่แน่ใจว่าเป็นวิธีที่สั้น

เครื่องมือที่มีประโยชน์สำหรับการรีสตาร์ทแอปพลิเคชันเมื่อมีการเปลี่ยนแปลงแหล่งที่มา ฉันทำสิ่งนี้เมื่อเล่นกับ pygame ดังนั้นฉันจึงเห็นเอฟเฟกต์เกิดขึ้นทันทีหลังจากบันทึกไฟล์

เมื่อใช้ใน pygame ตรวจสอบให้แน่ใจว่าเนื้อหาใน 'while' loop ถูกวางไว้ในลูปเกมของคุณหรือที่อัปเดต ไม่เช่นนั้นแอปพลิเคชันของคุณจะติดอยู่ในวงวนไม่ จำกัด และคุณจะไม่เห็นการอัปเดตเกมของคุณ

file_size_stored = os.stat('neuron.py').st_size

  while True:
    try:
      file_size_current = os.stat('neuron.py').st_size
      if file_size_stored != file_size_current:
        restart_program()
    except: 
      pass

ในกรณีที่คุณต้องการรหัสรีสตาร์ทที่ฉันพบบนเว็บ นี่มันคือ (ไม่เกี่ยวข้องกับคำถามแม้ว่าอาจมีประโยชน์)

def restart_program(): #restart application
    python = sys.executable
    os.execl(python, python, * sys.argv)

ขอให้สนุกกับการทำให้อิเล็กตรอนทำในสิ่งที่คุณต้องการ

ACTIONS = {
  1 : "Created",
  2 : "Deleted",
  3 : "Updated",
  4 : "Renamed from something",
  5 : "Renamed to something"
}
FILE_LIST_DIRECTORY = 0x0001

class myThread (threading.Thread):
    def __init__(self, threadID, fileName, directory, origin):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.fileName = fileName
        self.daemon = True
        self.dir = directory
        self.originalFile = origin
    def run(self):
        startMonitor(self.fileName, self.dir, self.originalFile)

def startMonitor(fileMonitoring,dirPath,originalFile):
    hDir = win32file.CreateFile (
        dirPath,
        FILE_LIST_DIRECTORY,
        win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
        None,
        win32con.OPEN_EXISTING,
        win32con.FILE_FLAG_BACKUP_SEMANTICS,
        None
    )
    # Wait for new data and call ProcessNewData for each new chunk that's
    # written
    while 1:
        # Wait for a change to occur
        results = win32file.ReadDirectoryChangesW (
            hDir,
            1024,
            False,
            win32con.FILE_NOTIFY_CHANGE_LAST_WRITE,
            None,
            None
        )
        # For each change, check to see if it's updating the file we're
        # interested in
        for action, file_M in results:
            full_filename = os.path.join (dirPath, file_M)
            #print file, ACTIONS.get (action, "Unknown")
            if len(full_filename) == len(fileMonitoring) and action == 3:
                #copy to main file
                ...

นี่คือตัวอย่างที่เน้นไปที่การรับชมไฟล์อินพุตที่เขียนไม่เกินหนึ่งบรรทัดต่อวินาที แต่มักจะน้อยกว่ามาก เป้าหมายคือการต่อท้ายบรรทัดสุดท้าย (การเขียนล่าสุด) กับไฟล์เอาต์พุตที่ระบุ ฉันได้คัดลอกสิ่งนี้จากหนึ่งในโครงการของฉันและเพิ่งลบบรรทัดที่ไม่เกี่ยวข้องทั้งหมด คุณจะต้องกรอกหรือเปลี่ยนสัญลักษณ์ที่หายไป

from PyQt5.QtCore import QFileSystemWatcher, QSettings, QThread
from ui_main_window import Ui_MainWindow   # Qt Creator gen'd 

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)
        Ui_MainWindow.__init__(self)
        self._fileWatcher = QFileSystemWatcher()
        self._fileWatcher.fileChanged.connect(self.fileChanged)

    def fileChanged(self, filepath):
        QThread.msleep(300)    # Reqd on some machines, give chance for write to complete
        # ^^ About to test this, may need more sophisticated solution
        with open(filepath) as file:
            lastLine = list(file)[-1]
        destPath = self._filemap[filepath]['dest file']
        with open(destPath, 'a') as out_file:               # a= append
            out_file.writelines([lastLine])

แน่นอนคลาส QMainWindow ที่ครอบคลุมไม่จำเป็นต้องใช้อย่างเคร่งครัดเช่น คุณสามารถใช้ QFileSystemWatcher เพียงอย่างเดียว

คุณยังสามารถใช้ไลบรารีแบบง่ายที่เรียกว่าrepytนี่คือตัวอย่าง:

repyt ./app.py

ดูเหมือนว่าไม่มีใครโพสต์fswatch fswatchเป็นผู้เฝ้าดูระบบไฟล์ข้ามแพลตฟอร์ม เพียงติดตั้งรันและปฏิบัติตามคำแนะนำ

ฉันใช้มันกับโปรแกรมหลามและ golang และมันใช้งานได้

โซลูชั่น @ 4Oh4 ที่เกี่ยวข้องเปลี่ยนแปลงได้อย่างราบรื่นสำหรับรายการไฟล์ที่ต้องดู

import os
import sys
import time

class Watcher(object):
    running = True
    refresh_delay_secs = 1

    # Constructor
    def __init__(self, watch_files, call_func_on_change=None, *args, **kwargs):
        self._cached_stamp = 0
        self._cached_stamp_files = {}
        self.filenames = watch_files
        self.call_func_on_change = call_func_on_change
        self.args = args
        self.kwargs = kwargs

    # Look for changes
    def look(self):
        for file in self.filenames:
            stamp = os.stat(file).st_mtime
            if not file in self._cached_stamp_files:
                self._cached_stamp_files[file] = 0
            if stamp != self._cached_stamp_files[file]:
                self._cached_stamp_files[file] = stamp
                # File has changed, so do something...
                file_to_read = open(file, 'r')
                value = file_to_read.read()
                print("value from file", value)
                file_to_read.seek(0)
                if self.call_func_on_change is not None:
                    self.call_func_on_change(*self.args, **self.kwargs)

    # Keep watching in a loop
    def watch(self):
        while self.running:
            try:
                # Look for changes
                time.sleep(self.refresh_delay_secs)
                self.look()
            except KeyboardInterrupt:
                print('\nDone')
                break
            except FileNotFoundError:
                # Action on file not found
                pass
            except Exception as e:
                print(e)
                print('Unhandled error: %s' % sys.exc_info()[0])

# Call this function each time a change happens
def custom_action(text):
    print(text)
    # pass

watch_files = ['/Users/mexekanez/my_file.txt', '/Users/mexekanez/my_file1.txt']

# watcher = Watcher(watch_file)  # simple



if __name__ == "__main__":
    watcher = Watcher(watch_files, custom_action, text='yes, changed')  # also call custom action function
    watcher.watch()  # start the watch going

ทางออกที่ดีที่สุดและง่ายที่สุดคือใช้ pygtail: https://pypi.python.org/pypi/pygtail

from pygtail import Pygtail
import sys

while True:
    for line in Pygtail("some.log"):
        sys.stdout.write(line)

ฉันไม่รู้ฟังก์ชันเฉพาะของ Windows คุณสามารถลองรับ MD5 hash ของไฟล์ทุกวินาที / นาที / ชั่วโมง (ขึ้นอยู่กับความเร็วที่คุณต้องการ) และเปรียบเทียบกับแฮชสุดท้าย เมื่อมันแตกต่างคุณรู้ว่าไฟล์มีการเปลี่ยนแปลงและคุณอ่านบรรทัดใหม่ล่าสุด

ฉันจะลองแบบนี้

    try:
            f = open(filePath)
    except IOError:
            print "No such file: %s" % filePath
            raw_input("Press Enter to close window")
    try:
            lines = f.readlines()
            while True:
                    line = f.readline()
                    try:
                            if not line:
                                    time.sleep(1)
                            else:
                                    functionThatAnalisesTheLine(line)
                    except Exception, e:
                            # handle the exception somehow (for example, log the trace) and raise the same exception again
                            raw_input("Press Enter to close window")
                            raise e
    finally:
            f.close()

การวนซ้ำจะตรวจสอบว่ามีบรรทัดใหม่หรือไม่ตั้งแต่มีการอ่านไฟล์ครั้งล่าสุดถ้ามีจะเป็นการอ่านและส่งผ่านไปยังfunctionThatAnalisesTheLineฟังก์ชัน ถ้าไม่ใช่สคริปต์จะรอ 1 วินาทีและลองใหม่อีกครั้ง