Python отслеживание появления файла

How to create a watchdog in Python to look for filesystem changes

Hey guys, today’s post is about how to create a watchdog in Python. But what is a “watchdog”?
A watchdog is a little piece of software that monitors our filesystem looking for any changes (like the creation, change or deletion of a file or of a directory). When a change occurs, the watchdog report it to us raising a specific event that we can handle.
For example, let’s suppose you have developed a program that use a configuration file. Your program could set a watchdog to monitor that file and if the configuration file is modified you could think to reload it and apply the new configuration at runtime, without the need of restarting your program.
That’s cool, uh?
So, today we will code a watchdog in Python.
To code this program we will need an additional module called “watchdog” (wow, who could have guessed it?) written by Yesudeep Mangalapilly, so let’s start by installing it. As always, I raccomand to use virtual environments instead of installing packages system wide. If you want to find out more about virtual environments (that’s probabilly because you haven’t read all my previous post, so shame on you!), just have a look at this article.
Now, create your virtual environment (optional but raccomended… at least by me), activate it and install the package watchdog with the following command:

Done, we have almost finished, haven’t we?
I mean, we still need to code the program that will actually use this module, but trust me, that will be really easy!

Ok, let’s start and pretend that we want to create a program that logs all the file that are created or modified in the same directory of our program.

Step 1. Import some stuff

import time from watchdog.observers import Observer from watchdog.events import PatternMatchingEventHandler 

I won’t explain these imports right now, they will be clear in a moment.

Step 2. Create the event handler

The event handler is the object that will be notified when something happen on the filesystem you are monitoring.

if __name__ == "__main__": patterns = ["*"] ignore_patterns = None ignore_directories = False case_sensitive = True my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive) 

In my example I have used some variables just to made the configuration of the event handler a little bit easier to be undestood.
The “patterns” variable contains the file patterns we want to handle (in my scenario, I will handle all the files), the “ignore_patterns” variable contains the patterns that we don’t want to handle, the “ignore_directories” is just a boolean that we can set to True if we want to be notified just for regular files (not for directories) and the “case_sensitive” variable is just another boolean that, if set to “True”, made the patterns we previously introduced “case sensitive” (that’s normally a good idea, unless you are working with stupid case-insensitive-file-systems… yeah, I’m talking about you Windows! 😛 ).

Step 3. Handle all the events

Now that we have created the handler we need to write the code we want to run when the events are raised.
So, let’s start creating four different functions that will be used when a file is modified, created, deleted or moved.

def on_created(event): print(f"hey, event.src_path> has been created!") def on_deleted(event): print(f"what the f**k! Someone deleted event.src_path>!") def on_modified(event): print(f"hey buddy, event.src_path> has been modified") def on_moved(event): print(f"ok ok ok, someone moved event.src_path> to event.dest_path>") 

In our example we will just print out something regarding the events that has been captured.
It goes without saying that this is just an example, we could execute any kind of code instead of these useless print functions…

And now, under the creation of our event handler (the code of the previous step) we need to specify to the handler that we want these functions to be called when the corresponding event is raised

my_event_handler.on_created = on_created my_event_handler.on_deleted = on_deleted my_event_handler.on_modified = on_modified my_event_handler.on_moved = on_moved 

Step 4. Create an observer

We need another object, known as the observer, that will monitor our filesystem, looking for changes that will be handled by the event handler.

 path = "." go_recursively = True my_observer = Observer() my_observer.schedule(my_event_handler, path, recursive=go_recursively) 

As you can see, I have just created an object of the Observer class and then called the schedule method, passing to it:

• the event handler that will handle the event
• the path to be monitored (in my case is “.”, that’s the current directory)
• a boolean that allow me to catch all the event that occurs even in the sub directories of my current directory.

Step 5. Start the observer

Ok, we almost finished our program, now we need just to start the observer thread.

 my_observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: my_observer.stop() my_observer.join() 

I think this snippet doesn’t need any comments, does it? We are just starting the observer thread to get all the events.

Ok, if everything is correct the result should be the one you can see below.

Testing our new shiny watchdog

And now it’s showtime guys, let’s test our watchdog!

Start the program from a terminal and you will see your cursor just hang. That’s a good start.

Now open a different terminal, move under the directory of your program and try to do something. For example, I have started vim (my favourite editor) to create a file:

by the time vim started, in my running console some statement has been printed:

hey, ./.dave.txt.swp has been created! hey buddy, . has been modified 

Wow, it works! When you try to create a file with Vim it start by creating a .swp file and that’s what our program has detected, printing the first line. But why the second line? Well, if the current directory has a new file we can say that it’s changed as well, can’t we?

Now I will try to save my file and…

hey, ./dave.txt has been created! hey buddy, . has been modified 

Ok, Vim has created my file (dave.txt) and my program has detected it! Well done!

Now I quit vim (for the record and for all the “Windows guys” that are currently reading this… you don’t need to unplug the power cord of your pc to quit vim, it’s enough to press the [esc] key and to type :q )

what the f**k! Someone deleted ./.dave.txt.swp! hey buddy, . has been modified 

Ok, vim has deleted the temporary .swp file and the program has detected it. Mission accomplished! 🙂

The bottom line

In this article you have seen how easy it could be to set up a watchdog in Python that monitors a filesystem and react when a change occurs.

If you want to find out more about the watchdog module, you can have a look at the official documentation.

You May Also Enjoy

The Sunday tip #2: Measuring Python code performance with the timeit module

4 minute read Good code is also code that performs well, here’s how you can measure your code’s performance in Python

The Sunday tip #1: Python cached integers

Managing Python versions with pyenv

How to create a computer virus in Python

14 minute read Is it possible to create a self-replicating virus in Python? In this article, we’ll find out…

Источник

Watchdog¶

Python API library and shell utilities to monitor file system events.

If you want to use Python 2.6, you should stick with watchdog < 0.10.0.

If you want to use Python 2.7, 3.4 or 3.5, you should stick with watchdog < 1.0.0.

Directory monitoring made easy with¶

Get started quickly with a simple example in Quickstart .

Easy installation¶

You can use pip to install watchdog quickly and easily:

$ python -m pip install -U watchdog

Need more help with installing? See Installation .

User’s Guide¶

• Installation
  • Installing from PyPI using pip
  • Installing from source tarballs
  • Installing from the code repository
  • Dependencies
  • Supported Platforms (and Caveats)
  • A Simple Example
  • watchdog.events
  • watchdog.observers.api
  • watchdog.observers
  • watchdog.observers.polling
  • watchdog.utils
  • watchdog.utils.dirsnapshot
  • watchdog.tricks
  • Important URLs
  • Before you start
  • Setting up the Work Environment

  Contribute¶

  Found a bug in or want a feature added to watchdog ? You can fork the official code repository or file an issue ticket at the issue tracker. You can also ask questions at the official mailing list. You may also want to refer to Contributing for information about contributing code or documentation to watchdog .

  Источник