파일이 변경되었는지 어떻게 확인합니까?

변경 사항을보고 싶은 다른 프로세스에서 로그 파일을 작성하고 있습니다. 변경이 발생할 때마다 처리를 위해 새 데이터를 읽고 싶습니다.

가장 좋은 방법은 무엇입니까? PyWin32 라이브러리에서 일종의 후크가 있기를 바랐습니다. win32file.FindNextChangeNotification함수를 찾았 지만 특정 파일을 보도록 요청하는 방법을 모릅니다.

누군가 이와 같은 일을한다면 정말 어떻게 들었는지 감사하게 생각합니다.

[편집] 필자는 폴링이 필요없는 솔루션을 따르고 있다고 언급 했어야합니다.

[편집] 저주! 매핑 된 네트워크 드라이브에서는 작동하지 않는 것 같습니다. Windows가 로컬 디스크에서와 같은 방식으로 파일에 대한 업데이트를 듣지 않는다고 생각합니다.

http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html 에있는 설명서를 이미 보셨습니까 ? Windows에서만 작동 해야하는 경우 두 번째 예는 정확히 원하는 것 같습니다 (보고 싶은 파일 중 하나와 디렉토리 경로를 교환하는 경우).

그렇지 않으면, 폴링은 아마도 플랫폼에 독립적 인 유일한 옵션 일 것입니다.

참고 : 나는 이러한 해결책을 시도하지 않았습니다.

워치 독 을 사용해 보셨습니까 ?

파일 시스템 이벤트를 모니터링하는 Python API 라이브러리 및 셸 유틸리티

간편한 디렉토리 모니터링

• 크로스 플랫폼 API.
• 디렉토리 변경에 대한 응답으로 명령을 실행하는 쉘 도구입니다.

빠른 시작 의 간단한 예제로 빠르게 시작하십시오 ...

폴링이 충분하다면 "수정 된 시간"파일 통계가 변경되는지 확인합니다. 그것을 읽으려면 :

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? 일 수 있음) UNIX 사용자의 경우 "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를 대체하고 (디렉토리 레벨 모니터링보다는 파일 레벨을 허용합니다).

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

비슷한 질문에 대한 답변 을 확인하십시오 . 파이썬에서 같은 루프를 시도 할 수 있습니다. 이 페이지 는 다음을 제안합니다.

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

또한 파이썬으로 파일 tail () 질문을 참조하십시오 .

나를위한 가장 간단한 해결책은 워치 독 도구 watchmedo를 사용하는 것입니다.

에서 https://pypi.python.org/pypi/watchdog 지금은 프로세스를하는 SQL 디렉토리에있는 파일 및 실행하는 그들을 필요한 경우 찾습니다.

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

글쎄, 파이썬을 사용하고 있기 때문에 파일을 열고 그 줄을 계속 읽을 수 있습니다.

f = open('file.log')

읽은 줄이 비어 있지 않으면 처리합니다.

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

readlineEOF에서 계속 전화 를 해도 괜찮습니다 . 이 경우 빈 문자열을 계속 반환합니다. 그리고 로그 파일에 무언가가 추가되면 필요에 따라 중지 된 위치부터 계속 읽습니다.

이벤트 또는 특정 라이브러리를 사용하는 솔루션을 찾고 있다면 질문에 지정하십시오. 그렇지 않으면이 솔루션이 훌륭하다고 생각합니다.

다음은 동일한 트릭을 수행하고 전체 파일을 가져 오지 않는 간단한 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

이것은 Unix 유형에서 실행되고 dict (file => time)를 사용하여 파일 수정을위한 간단한 감시자를 추가하는 Tim Goldan 스크립트의 또 다른 수정입니다.

사용법 : whateverName.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

Horst Gutmann이 지적한 Tim Golden의 기사 에서 볼 수 있듯이 WIN32는 비교적 복잡하며 단일 파일이 아닌 디렉토리를 감시합니다.

나는 당신이 조사 제안하고 싶습니다 IronPython의 A는, .NET의 파이썬 구현입니다. IronPython을 사용하면 다음을 포함한 모든 .NET 기능을 사용할 수 있습니다

System.IO.FileSystemWatcher

간단한 이벤트 인터페이스로 단일 파일을 처리합니다 .

변경 사항을 파일에서 확인하는 예입니다. 가장 좋은 방법은 아니지만 짧은 방법입니다.

소스가 변경되었을 때 응용 프로그램을 다시 시작하는 데 유용한 도구입니다. 파이 게임을 할 때 이것을 만들었으므로 파일 저장 직후에 효과가 발생하는 것을 볼 수 있습니다.

파이 게임에서 사용될 때 'while'루프에있는 것들이 게임 루프에 업데이트 또는 그 밖의 무엇이든 위치해야합니다. 그렇지 않으면 응용 프로그램이 무한 루프에 빠지고 게임 업데이트가 표시되지 않습니다.

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 를 게시하지 않은 것 같습니다 . 크로스 플랫폼 파일 시스템 감시자입니다. 설치하고 실행 한 후 지시를 따르십시오.

파이썬 및 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

가장 좋고 가장 간단한 해결책은 피그 테일을 사용하는 것입니다 : 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 해시 (필요한 속도에 따라 다름)를 가져 와서 마지막 해시와 비교할 수 있습니다. 다른 경우 파일이 변경되었음을 알고 최신 줄을 읽습니다.

나는 이런 식으로 시도 할 것입니다.

    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 초 동안 대기 한 후 프로세스를 재 시도합니다.