telegram.py

#!/usr/bin/python3

import requests

class telegram():
    def __init__(
        self,
        TelegramToken,
        TelegramChatID,
    ):
        self.TelegramToken = TelegramToken
        self.TelegramChatID = TelegramChatID
    def send_message(self, text):
        files = {
            'chat_id': (None, self.TelegramChatID),
            'text': text,
        }
        response = requests.get("https://api.telegram.org/bot"+self.TelegramToken+"/sendMessage?chat_id="+self.TelegramChatID+"&text="+text, files=files)
        return response
    
    def send_file(self, FileName, FilePath):
        files = {
            'chat_id': (None, self.TelegramChatID),
            'document': (FileName, open(FilePath, 'rb')),
        }
        response = requests.post("https://api.telegram.org/bot"+self.TelegramToken+"/sendDocument", files=files)
        return response
    
    def send_video(self, FileName, FilePath):
        files = {
            'chat_id': (None, self.TelegramChatID),
            'video': (FileName, open(FilePath, 'rb')),
        }
        response = requests.post("https://api.telegram.org/bot"+self.TelegramToken+"/sendVideo", files=files)
        return response

watchdog_events_zm.py

#!/usr/bin/python3

import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import datetime
from subprocess import Popen,DEVNULL

# https://realpython.com/python-logging/
import sys
sys.path.append("/root/watchdog/")
from watchdog_logging import *

import telegram

class MyHandler(FileSystemEventHandler):
    def __init__(
        self,
        logger,
        telegram,
    ):
        self.AlreadySended = []
        self.logger = logger
        self.telegram = telegram
    
    def on_modified(self, event):
        self.logger.error(f"File modified: {event.src_path}")
    
    def on_created(self, event):
        self.logger.error(f"File created: {event.src_path}")
        if '.mp4' in event.src_path and \
                not event.src_path in self.AlreadySended and \
                not '.incomplete' in event.src_path: : # This avoid send file than once.
            
            # Waits until the zm finish the generation of the file.
            while True:
                if Popen(['/usr/bin/lsof', event.src_path], stdout=DEVNULL, stderr=DEVNULL).wait() == 0:
                    time.sleep(2)
                    self.logger.error(f'File {event.src_path} is still opened')
                    continue
                else:
                    break
            
            self.logger.error(f'File {event.src_path} copy has now finished')
            
            # Send telegram message about the event
            #Text = f'event type: {event.event_type}  path : {event.src_path}'
            #self.telegram.send_message(Tex)
            
            # Send the file via telegram
            self.logger.error(f'Sending file via telegram. Group: {self.telegram.TelegramChatID}')
            Time = datetime.datetime.now()
            FileName='Video_'+str(Time.day)+"-"+str(Time.month)+\
                    "-"+str(Time.year)+"_"+str(Time.hour)+"-"+\
                    str(Time.minute)+"-"+str(Time.second)+".mp4"
            
            # Send file to telegram
            attempts=0
            while attempts < 10:
                try:
                    self.telegram.send_video(FileName, event.src_path)
                    self.logger.error('File sended')
                    self.AlreadySended.append(event.src_path)
                    break
                except:
                    attempts += 1
                    self.logger.error('Error trying send file.')
    
    def on_deleted(self, event):
        self.logger.error(f"File deleted: {event.src_path}")
    
    def on_moved(self, event):
        self.logger.error(f"File moved: {event.src_path} to {event.dest_path}")

path = '/media/pd/zoneminder/events/2/'

if __name__ == "__main__":
    tg = telegram.telegram(
            TelegramToken = "< Your bot token here>",
            TelegramChatID = '< Your chat ID here >')
    event_handler = MyHandler(
            logger = logger,
            telegram = tg)
    observer = Observer()
    observer.schedule(event_handler, path, recursive=True)
    observer.start()
    
    try:
        while True:
            time.sleep(60)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

watchdog_logging.py

#!/usr/bin/python3

# https://realpython.com/python-logging/

import logging
from logging.handlers import RotatingFileHandler

# Create a custom logger
logger = logging.getLogger(__name__)

# Create handlers
c_handler = logging.StreamHandler()
c_handler.setLevel(logging.NOTSET)

f_handler = logging.FileHandler('/tmp/watchdog_zoneminder.log')
f_handler.setLevel(logging.DEBUG)

# Create formatters and add it to handlers
c_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', '%m/%d/%Y %I:%M:%S')
c_handler.setFormatter(c_format)

f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s', '%m/%d/%Y %I:%M:%S')
f_handler.setFormatter(f_format)

# Rotate the log file.
rotating_handler = RotatingFileHandler('/tmp/watchdog_zoneminder.log', maxBytes=2000, backupCount=5)
logger.addHandler(rotating_handler)

# Add handlers to the logger
logger.addHandler(c_handler)
logger.addHandler(f_handler)

I was getting to messages in telegram I thing the mechanism used to detect that the mp4 file is ready and complete - is not working properly.
But I see that new mp4 files that are created are created with the 'incomplete' prefix in the filename.
so I used that to only send the file when it is complete.
you can see the change in my gist:
https://gist.github.com/GuyKroizman/7de7e899db4ddaccf9f819d7b2131db7