Утилита для работы с архивными каталогами

Часто возникает желание привести свои фото-видео и просто архивы впорядок, но никогда не хватает терпения сделать это вручную. Решил написать удобную утилитку для поиска дубликатов ( дубликатами считаюся файлы с одинаковым содержимым, точнее с одинаковым md5 hexdigest, хотя они могут иметь и разные имена ) в "архивных"(raw) каталогах и поискать во всех возможных местах "потерянные"(uniq) файлы т.е файлы отсутствуразветвительющие в "архивных"(raw) каталогах. Хотелось набросать это за пару часов и "хотелось, как лучше, а получилось, как всегда". Вместо пары часов ушло пару вечеров. И раз уж все равно потрачено много времени, хочется довести эту утилитку до "более законченного" сосотояния и услышать от Питонистов их менение, замечания и просто пожелания по поводу: оптимизации, стиля, форматирования/оформления кода, именования переменных и т.д. В общем любая конструктивная критика приветствуется. Надеюсь с вашей помощью поучить что-то полезное не только для себя. Возможности настройки и использование должны быть понятны из кода (безусловно по возможности добавлю описание)

Вкратце

Утилита только читает каталоги и ничего не меняет. Пока, не меняет, в следующих версиях возможно будет. Утилита принимает на вход либо конфигурационный файл, либо опции коммандной строки(command-line) Например: ./ardiff.py --config=test.conf , либо и то и то, при этом command-line опции имеют приоритет. Основной параметр это "архивный каталог"(raw) или их список в которых будет осуществляться поиск дубликатов. Например вот так: ./ardiff.py --raw=dir1,dir2 #через запятую без пробелов. Могут быть указаны абсолютные пути или только их "относительная"(name) часть. Относительная по отношению к текущему каталогу или к каталогу, указанному в --raw-root./ardiff.py --raw-root=/home/user/photo-arch --raw=dir1,dir2 Аналогичным способом можно указать "внешние"(raw-sorted) каталоги, где будет осуществряться поиск недостающих(uniq) в "архивных"(raw) каталогах файлов. Еще можно управлять выводом результатов работы, их можно выводить на экран --verbose=2 и/или в файлы см. пример ниже.

Рабочий пример

В этом примере, утилита запускается с опциями, при которых будут найдены все дубликаты файлов в подкаталогах dir1 и dir2, которые находятся в каталоге /home/user/photo-arch, затем будут найдены все файлы, которые есть в подкаталогах dir3, dir4 и dir5 каталога photo-arch на внешнем носителе примонтированном к /media/user/3XX, при этом результаты будут выведены, как на экран, так и в файлы в каталоге ./folder-for-results.


./adiff.py  --raw-root=/home/user/photo-arch --raw=dir1,dir2 --raw-sorted-root=/media/user/3XX/photo-arch
--raw-sorted=dir3,dir5 --dup_prefix=dup- --check_dup=Y --uniq_prefix=uniq- --check_uniq=Y 
--out_root=folder-for-results --verbose=2
Чтобы было не очень скучно сидеть, пока утилита перетряхивает гигабайты ваших арховов, при verbose = 1 на stdout, а при verbose = 2 на stderr, будет выводиться количество просмотренных каталогов, файлов и скорость из обхода в файлах в секунду. Утилитка пока сырая, но в умелых руках, вполне полезная и, как я уже писал, вполне безопасная, потому что ничего не удаляет и не пишет, кроме не очень больших файлов с результатами работы. Да и их порождение можно отключить.
Не судите строго, и это именно тот не частый случай, когда помогать советом - уместно.

Теперь исходники

Файл: ardiff.py

#!/usr/bin/env python
# encoding: utf-8
'''
fsutils.ardiff -- Utility to help cleaning up the files archives/catalogs

fsutils.ardiff is an utility to help cleaning up the files(photo,video, etc.) 
archives/catalogs. For now it is do only look up for duplicates thru the 
"main"/"raw" archives/catalogs. Also this utility can find unique files (files
which not in the "main"/"raw" archives) in external catalogs. 

It defines classes_and_methods

@author:	 Gurman

@copyright:  2014 Gurman Inc. All rights reserved.

@license:	"Copyright 2014 Gurman (Gurman Inc.)    	\
			Licensed under the Apache License 2.0\n		\
			http://www.apache.org/licenses/LICENSE-2.0" 

@contact:	apgurman@gmail.com
@deffield	updated: Updated
'''
import sys
import os
import md5
import time

from kcommon import OptionParserWraper
from kcommon import err_report
from kcommon import CatalogsWalker
from kcommon import OutSplitter

__all__ = []
__version__ = "v0.1"
__date__ = '2014-11-24'
__update__='2014-11-24'

__version_string__ = '%%prog %s (%s)' % (__version__, __update__)

DEBUG = 1

__SORTED_SUFFIX__= "sorted.txt"
__ASIS_SUFFIX__= "asis.txt"

class FileInfo(object):
	""" Class to hold file info """
	
	def __init__(self,_path,_name=None):
		""" if _path only passed the _path == path+name """
		self.__size, self.__hexdigest = None, None
		if _name is None:
			self.__path = os.path.dirname(_path)
			self.__name = os.path.basename(_path)		  
		else:
			self.__path, self.__name = _path, _name
		
			
	@property		
	def path(self):
		return self.__path
	
	@property		
	def name(self):
		return self.__name
	
	@property
	def full_name(self):
		return os.path.join(self.path,self.name)
	
	@property
	def size(self):
		""" calculate if need and return size for file """
		if self.__size is None:
			self.__size = os.stat(self.full_name).st_size
		return self.__size
	
	@property
	def hexdigest(self):
		""" calculate if need and return md5 hexdigest for file """
		if self.__hexdigest is None:
			_md5 = md5.new()
			_file = open(self.full_name, 'rb')
			_block = _file.read(_md5.block_size)
			while _block:
				_md5.update(_block)
				_block = _file.read(_md5.block_size)
			self.__hexdigest = _md5.hexdigest()
		return self.__hexdigest
	
	@hexdigest.setter
	def hexdigest(self,_hxd):
		""" hexdigest setter if we want to use something specific """
		self.__hexdigest = _hxd
		return self.__hexdigest
	
	def __eq__(self,finfo):
		if finfo.size == self.size:
			if self.name == finfo.name:
				return True
			else:
				if self.hexdigest == finfo.hexdigest:
					return True
		return False
	
	def __ne__(self, o):
		return not self.__eq__(o)
	
	def is_in(self,_flist):
		for finfo in _flist:
			if self.__eq__(finfo):
				return True
		return False
						

class RawCatalogs(object):

	"""Class to manipulate and hold list of raw(archive) catalogs - main storage """

	def __init__(self, opts ):
		self.__count = 0
		self.__opts=opts
		
		ctlgs=opts.raw.split(',')
		self.__raw_catalogs = [os.path.join(opts.raw_root,x) for x in ctlgs] if opts.raw_root else ctlgs
		
		self.__out_splitter = OutSplitter([sys.stdout]) if opts.verbose == 1  else OutSplitter([sys.stderr])
		
		self.__raw_files, self.__raw_dup_files, self.__uniq_files = None, None, None

	@property
	def raw_files(self):
		if self.__raw_files  is None:
			self.__raw_files = {}
			self._add_arhs(self.__raw_catalogs)
		return self.__raw_files
	
	@property			
	def raw_dup_files(self):
		if self.__raw_dup_files is None:
			self.__raw_dup_files = {}
			self.raw_files
		return self.__raw_dup_files
	
	@property
	def uniq_files(self):
		if self.__uniq_files is None:
			self.__uniq_files = {}
		return self.__uniq_files
	
	def _check_duplicate(self, finfo):
		""" checks if the file's info already in archives """
		for i in self.__raw_files[finfo.size]:
			if finfo.hexdigest == i.hexdigest:
				#First duplicate
				if finfo.hexdigest not in self.__raw_dup_files:
					d = []; d.append(i)
					self.__raw_dup_files[finfo.hexdigest] = d
				else:	#More then one duplicate
					pass
				#Remembering all duplicates
				self.__raw_dup_files[finfo.hexdigest].append(finfo)
			else: #Same size but different files 
				pass
		
	def _add_to_arh_dict(self, finfo):
		""" add file's information to archives """
		if finfo.size not in self.raw_files:
			self.raw_files[finfo.size] = []
		elif self.__opts.check_dup == 'Y' :	
			self._check_duplicate(finfo)
			
		self.raw_files[finfo.size].append(finfo)
		
	def _add_arhs(self,_catalogs, out_splitter=None):
		""" main loop thru the archives to create internal structures """
		
		if out_splitter is None: out_splitter = self.__out_splitter
		
		for p,n in CatalogsWalker(_catalogs, out_splitter):
			finfo = FileInfo(p,n)
			self._add_to_arh_dict(finfo)
	
	def check_for_uniq_files(self,_catalogs,rfs=None,out_splitter=None):
		""" look up external catalogs for files which isn't in archives """
		uniq_files={}
		
		rfs = self.raw_files if rfs is None else rfs
		
		if out_splitter is None: out_splitter = self.__out_splitter
		
		cw=CatalogsWalker(_catalogs,out_splitter)
		for p,n in cw:
			
			finfo = FileInfo(p,n)
			
			if finfo.size in rfs:
				if not finfo.is_in(rfs[finfo.size]):
					if finfo.hexdigest not in uniq_files:
						x = []; x.append(finfo)
						uniq_files[finfo.hexdigest] = x
								
			elif finfo.hexdigest not in uniq_files:
					x = []; x.append(finfo)
					uniq_files[finfo.hexdigest] = x
					
		return uniq_files
	
	def group_by_folders(self,d):
		pd={}
		for i in d:
			for z in d[i]:
				if z.path not in pd:
					pd[z.path]=[]
				pd[z.path].append(z)
		return pd

	def print_as_is(self,n,d,outs):
		if not hasattr(outs, 'write') : return
		w = outs.write
		w(n)
		for i in d:
			w("\n")
			for x in d[i]:
				w(x.hexdigest+repr(x.size).rjust(12)+(x.full_name).rjust(64)+'\n')
		w("\n")	
						
	def print_sorted_by_full_name(self,d,outs):
		if not hasattr(outs, 'write') : return
		for i in sorted(d.items(), key=lambda x: x[1][0].full_name):
			print '\n',
			for z in d[i]:
				print z.full_name,"\t", z.size,"\t",z.hexdigest
		print "\n"
	
	def print_sorted_by_catalogs_and_names(self, n, d,outs):
		if not hasattr(outs, 'write') : return
		w = outs.write
		w(n)
		for i in d:
			w('\n\npath='+ i+ "\nfiles=")
			for z in sorted(d[i], key=lambda x: x.name):
				w(z.name + ',') #,"\t", z.size,"\t",z.hexdigest
		w("\n")
				
def _time_str():
	gmt=time.gmtime()
	return  '-'+str(gmt.tm_year)+'-'+str(gmt.tm_mon)+'-'+str(gmt.tm_mday)+'-'+str(gmt.tm_hour)+\
	 	 '-'+str(gmt.tm_min)+'-'+str(gmt.tm_sec)+'-'
		
def main_scenario(opts,args):
	
	rctlgs=RawCatalogs(opts)
	
	stdouts = sys.stdout if opts.verbose == 2 else None

	if opts.check_dup == 'Y' :
		rctlgs.raw_dup_files
		
		r, p = opts.out_root, opts.dup_prefix
		fout_prefix = ( os.path.join(r, p+_time_str()) if r else p + _time_str() ) if p else None 			
		
		if fout_prefix or stdouts: 
			fout_prefix_ = fout_prefix + __SORTED_SUFFIX__ if fout_prefix else None
			out_splitter = OutSplitter([stdouts, fout_prefix_])
			if out_splitter.pipes:
				rctlgs.print_sorted_by_catalogs_and_names("\n[SORTED DUPLICATES]\n",
					 	 	 rctlgs.group_by_folders(rctlgs.raw_dup_files), 
						 	 out_splitter)
			fout_prefix_ = fout_prefix + "-asis.txt" if fout_prefix else None	
			out_splitter = OutSplitter([stdouts, fout_prefix_])
			if out_splitter.pipes:
				rctlgs.print_as_is("\n[DUPLICATES]\n", 
								rctlgs.raw_dup_files, 
								out_splitter)

	if opts.check_uniq == "Y":
		_catalogs=opts.raw_sorted.split(',')
		_catalogs=[os.path.join(opts.raw_sorted_root,x) for x in _catalogs] if opts.raw_sorted_root else _catalogs
		rctlgs.check_for_uniq_files(_catalogs)
		
		r, p = opts.out_root, opts.uniq_prefix
		fout_prefix = ( os.path.join(r, p) if r else p ) if p else None 

		if fout_prefix or stdouts: 
			out_splitter = OutSplitter([stdouts, fout_prefix+__ASIS_SUFFIX__])
			if out_splitter.pipes:
				rctlgs.print_as_is("\n[UNIQS]\n",rctlgs.uniq_files, out_splitter) 
	
	print("\nThe end")
			
def main(argv=None):			
	
	try:
		
		opt_parser = OptionParserWraper(argv)#, version_string = __version_string__)
		
		main_scenario(opt_parser.opts,opt_parser.args)
	
	except Exception:
		err_report()
		return 2		


if __name__ == "__main__":
	if DEBUG:
		if len(sys.argv) == 1:
			sys.argv.append("--config=test.conf")
			pass

	sys.exit(main())

Файл: kcommon.py

#!/usr/bin/env python
# encoding: utf-8

import sys
import os
import time
from sets import Set

from optparse import OptionParser

__def_vers__ = "v0.1"
__def_duild_date__ = "2014-11-24"

def err_report():
    
    if sys.exc_info() != (None,None,None) : 
        last_type, last_value, last_traceback = sys.exc_info()
    else : 
        last_type, last_value, last_traceback = sys.last_type, sys.last_value, sys.last_traceback 
    
    tb, descript = last_traceback, []
    
    while tb :
        fname, lno = tb.tb_frame.f_code.co_filename, tb.tb_lineno
        descript.append('\tfile "%s", line %s, in %s\n'%(fname, lno, tb.tb_frame.f_code.co_name))
        tb = tb.tb_next
        
    descript.append('%s : %s\n'%(last_type.__name__, last_value))
    
    for i in descript : 
        sys.stderr.write(i),


class Error(Exception):
    """Base class for ardiff exceptions."""

    def __init__(self, msg=None):
        self.msg = msg

    def __str__(self):
        return self.msg
    
    #def __repr__(self, *args, **kwargs):
    #    return Exception.__repr__(self, *args, **kwargs)
    
class ConfigNotFoundError(Error):
    """Raised if config file passed but not found."""

    def __str__(self):
        return "call expression when config file passed but not found"
    
class OutSplitter(object):
    """ splitter """
    
    def __init__(self, out_splitter):
        self.__pipes=None
        if isinstance(out_splitter, OutSplitter):
                self.__pipes = Set(out_splitter.pipes)
        elif out_splitter:
            if hasattr(out_splitter,"__iter__") : #
                for pn in out_splitter:
                    self.add_pipe(pn)
            else:
                self.add_pipe(out_splitter)
                   
    @property
    def pipes(self):
        return self.__pipes
    
    def add_pipe(self, pn):
        if isinstance(pn, basestring):
            if pn == 'stderr': x = sys.stderr
            elif pn == 'stdout': x = sys.stdout
            else: 
                p = os.path.dirname(pn)
                if p and not os.path.exists(p):
                    os.makedirs(p)
                x = open(pn,'w+')
        else: x = pn
        
        if hasattr(x, 'write') and hasattr(x, 'flush'):
            if self.__pipes is None:
                self.__pipes=Set()
            self.__pipes.add(x)
    
    def write(self,s):
        if self.__pipes:
            for p in self.__pipes:
                p.write(s)
    
    def flush(self):
        if self.__pipes:
            for p in self.__pipes:
                p.flush()
                
class CatalogsWalker(OutSplitter):
    
    def __init__(self,catalogs,out_splitter=None):
        OutSplitter.__init__(self,out_splitter)        
        self.__catalogs = catalogs
        self.__file_counter, self.__catalog_counter, self.__start_time, self.__speed = 0, 0, 0, 0
        
    def __iter__(self):
        self.__file_counter, self.__catalog_counter, self.__start_time, self.__speed = 0, 0, 0, 0
        self.__start_time=time.time()
        for catalog in self.__catalogs:
            for p,d,ns in os.walk(catalog): 
                _ = d;
                self.__catalog_counter+=1
                for n in ns:
                    self.__file_counter+=1
                    self.__speed=self.__file_counter/(time.time()-self.__start_time)
                    self.fanny_indicator(self.__catalog_counter, self.__file_counter, self.__speed)
                    yield p,n
                    
    @property
    def catalog_counter(self):
        return self.__catalog_counter    
    
    @property
    def file_counter(self):
        return self.__file_counter
    
    @property
    def start_time(self):
        return self.__start_time
    
    @property
    def speed(self):
        return self.__speed    
    
    def fanny_indicator(self,p,n,s):
        if self.pipes:
            _result="\rcataloges:"+repr(p).rjust(8)+"\tfiles:"+repr(n).rjust(13)+"\tspeed: %12.3f"%s+" files/s"
            self.write(_result)
            self.flush()    

class OptionParserWraper(OptionParser):
    def __init__(self,argv,
                 version_string = '%%prog %s (%s)' % (__def_vers__, __def_duild_date__),
                 longdesc = '''''', # optional - give further explanation about what the program does
                 license_ = "Copyright 2014 Gurman (Gurman Inc.)                                            \
                    Licensed under the Apache License 2.0\nhttp://www.apache.org/licenses/LICENSE-2.0"                 
                 ):
        '''Command line options.'''
        # setup option parser
        OptionParser.__init__(self,
                              version=version_string, 
                              epilog=longdesc, 
                              description=license_)
        
        x=self.add_option
        x('--config', dest='config', default=None, metavar='FILE', 
          help='config file')
        x('--raw_root', dest='raw_root', default=None, metavar='PATH', 
          help='prefix(root path) for raw catalogs')        
        x('--raw', dest='raw', default='raw', metavar='DIRS', 
          help='list of raw catalogs names - archives names')
        x('--raw_sorted_root', dest='raw_sorted_root',default= None, metavar='PATH', 
          help='prefix(root path) for sorted raw catalogs')      
        x('--raw_sorted', dest='raw_sorted', default='raw_sorted', metavar='DIRS', 
          help='list of sorted raw catalogs names')
        x('--verbose',  dest='verbose', type=int, default=2, metavar='int', 
          help='level of verbosity')
        x('--check_dup', dest='check_dup', default='Y', metavar='Y/n', 
          help='Y for check duplicates default[Y]')
        x('--out_root', dest='out_root', default=None, metavar='FILE', 
          help='root dir to results output')
        x('--dup_prefix', dest='dup_prefix', default=None, metavar='FILE', 
          help='filenames prefix to out list of duplicate files')
        x('--check_uniq', dest='check_uniq', default='n', metavar='Y/n', 
          help='Y for check uniq files default[n]')
        x('--uniq_prefix', dest='uniq_prefix', default=None, metavar='FILE', 
          help='filenames prefix to out list of uniq files')
                       
        def config_parser_and_options_merger(filename, argv=None):
    
            cllps = (lambda s: ' '.join(s.split()))
            dopts = {}
        
            fconf = open(filename, 'r')
            for ln in fconf.read().split('\n'):
                
                if ln and ln[0] ==' #' or len(ln) 
Пример содержимого test.conf:

--raw_root=/home/user/photo/ 
--raw=dir1,dir2
#comments 1
--raw_sorted_root=/media/user/3XX/photo/ 
--raw_sorted=dir2,dir3
--out_root=results
--dup_prefix=dup-
--uniq_prefix=uniq-
--check_uniq=Y
--check_dup=Y
--verbose=2
26 Ноябрь 2014, 07:17 0 gurman
blog comments powered by Disqus