added config file

.gitignore

@@ -4,4 +4,5 @@ venv/
 prepare.egg-info/
 dist/
 build/
-prepare.log
+log/
+config/

prepare.py

@@ -7,38 +7,82 @@ import threading
 import time
 import logging
 import argparse
+import configparser
 
 from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip
 from pymediainfo import MediaInfo
 
-logging.basicConfig(filename='prepare.log', filemode='w', format='%(asctime)s \t %(threadName)s \t %(levelname)s \t '
+threading.current_thread().name = "main"
-                                                                 '%(message)s', level=logging.INFO)
 
 
+if not os.path.isdir('log'):
+    try:
+        os.makedirs('log')
+    except:
+        pass
+else:
+    pass
+
+a = 'log/' + str(time.strftime("%Y-%m-%d %H:%M:%S")) + '.log'
+logging.basicConfig(filename=a, filemode='w', format='%(asctime)s - %(threadName)s - %(levelname)s - %(message)s',
+                    level='INFO')
+
+logging.warning('Test warn')
+
 class Args:
     parser = ArgumentParser = argparse.ArgumentParser(
         description='Extracting mediainfo, sample and screens from random timecodes from video')
     parser.add_argument('-s', action='store_true', dest='screens', help="create screenshots")
-    parser.add_argument('-c', action='store_true', dest='sample', help="extract sample")
+    parser.add_argument('-S', action='store_true', dest='sample', help="extract sample")
     parser.add_argument('-m', action='store_true', dest='mediainfo', help='create mediainfo')
     parser.add_argument('-n', action='store', dest="count", default=10,
-                        help="number of screenshots, default 10", type=int)
+                        help="number of smcreenshots, default 10", type=int)
-    parser.add_argument('-i', action='store', dest='input', help="input file", required=True)
+    parser.add_argument('-c', action='store', dest='config', help='config file', default='config/config.ini', type=str)
+    parser.add_argument('-i', action='store', dest='input', help="input file", required=True, type=str)
     args = parser.parse_args()
     logging.info(' '.join(f'{k}={v}' for k, v in vars(args).items()))
 
 
+class Config:
+    config = configparser.ConfigParser()
+
+    config.add_section('Output')
+    config.set('Output', 'Dir', str(pathlib.Path.home()) + '/sample/')
+
+    if os.path.isdir('config'):
+        logging.info("Config dir is exist" )
+    else:
+        try:
+            os.makedirs('config')
+        except OSError:
+            logging.error("Creation of the directory config failed")
+        else:
+            logging.info("Successfully created the config directory")
+
+    if os.path.isfile(Args.args.config):
+        logging.info("Config is exist" )
+    else:
+        logging.info("Creating Config" )
+        with open(Args.args.config, 'w') as configfile:
+            config.write(configfile)
+
+
 class Head:
     """
     Creates mediainfo, screenshots and sample from file
     """
 
     def __init__(self):
+        config = configparser.ConfigParser()
+        config.read(Args.args.config)
+        output = config["Output"]
+        save_dir = output["dir"]
+
         procs = []
         self.bname: str
 
         self.bname = os.path.basename(Args.args.input)
-        self.fold = str(pathlib.Path.home()) + "/samples/" + os.path.splitext(self.bname)[0]
+        self.fold = save_dir + os.path.splitext(self.bname)[0]
         logging.info("Filename is %s" % self.bname)
 
         if os.path.isdir(self.fold):
@@ -61,26 +105,25 @@ class Head:
                                               'max_time': self.max_time})
             procs.append(thread)
             thread.start()
-            time.sleep(1)
 
         if Args.args.screens:
             logging.info("Rounded duration %ss" % self.max_time)
             logging.info("Creating %s screenshots" % Args.args.count)
+
             for self.num_screen in range(Args.args.count):
-                thread = threading.Thread(name="screens", target=Head.screens, args=(self, ),
+                thread = threading.Thread(name="screen_" + str(self.num_screen + 1), target=Head.screens, args=(self, ),
                                           kwargs={'fold': self.fold,
                                                   'max_time': self.max_time,
                                                   'num_screen': self.num_screen})
+
                 procs.append(thread)
                 thread.start()
-                time.sleep(1)
 
         if Args.args.mediainfo:
             thread = threading.Thread(name="mediainfo", target=Head.info(self, ),
                                       kwargs={'fold': self.fold})
             procs.append(thread)
             thread.start()
-            time.sleep(1)
 
         for proc in procs:
             proc.join()
@@ -93,11 +136,14 @@ class Head:
         sam = self.fold + "/sample" + os.path.splitext(self.bname)[1]
 
         if self.max_time <= 360:
-            logging.info(f"Creating Sample with duration {(self.max_time * 2 / 3) - (self.max_time / 3)}s")
+            t1 = self.max_time / 3
-            ffmpeg_extract_subclip(Args.args.input, self.max_time / 3, self.max_time * 2 / 3, targetname=sam)
+            t2 = self.max_time * 2 / 3
         else:
-            logging.info(f"Creating Sample with duration {(self.max_time / 2 + 60) - (self.max_time / 2 - 60)}s")
+            t1 = self.max_time / 2 - 60
-            ffmpeg_extract_subclip(Args.args.input, self.max_time / 2 - 60, self.max_time / 2 + 60, targetname=sam)
+            t2 = self.max_time / 2 + 60
+
+        logging.info(f"Creating Sample with duration {t2 - t1}s")
+        ffmpeg_extract_subclip(Args.args.input, t1, t2, targetname=sam)
 
     def info(self, **kwargs):
         media_info = MediaInfo.parse(Args.args.input, output="")
@@ -109,12 +155,13 @@ class Head:
 
     def screens(self, **kwargs):
         sec = random.randint(round(self.max_time * 0.05), round(self.max_time * 0.95))
-        imgname = self.fold + "/" + str(sec) + ".png"
+        logging.info(f"{self.num_screen + 1}st screen time {sec}s creating")
-        logging.info(f"{self.num_screen + 1}st screen time {sec}s\tthread is {threading.get_ident()}")
+
-        screen_create = editor.VideoFileClip(Args.args.input)
+        scr_cr = editor.VideoFileClip(Args.args.input)
-        screen_create.save_frame(imgname, t=sec)
+        scr_cr.save_frame(self.fold + "/" + str(sec) + ".png", t=sec)
-        screen_create.audio.reader.close_proc()
+        scr_cr.audio.reader.close_proc()
-        screen_create.reader.close()
+        scr_cr.reader.close()
+        logging.info(f"{self.num_screen + 1}st screen screated")
 
 
 if __name__ == '__main__':