def _save_cb(self, widget, data=None):
'''Save a task'''
input_buffer = self.text_input.get_buffer()
start, end = input_buffer.get_bounds()
text = input_buffer.get_text(start, end, False).strip()
text = strip_tag(text)
if len(text) > 0:
input_buffer.set_text('')
category = self.combobox_category.get_active()
priority = self.combobox_priority.get_active()
self.combobox_category.set_active(-1)
self.combobox_priority.set_active(-1)
date_formated = date_format(self.calendar.get_date())
data = (text, category, priority, 0, date_formated)
db = DataBase(self.path)
db.add(data)
db.close()
self.get_tasks()
self.mark_day()
def _save_cb(self, widget, data=None):
'''Save a task'''
input_buffer = self.text_input.get_buffer()
start, end = input_buffer.get_bounds()
text = input_buffer.get_text(start, end, False).strip()
text = strip_tag(text)
if len(text) > 0:
input_buffer.set_text('')
category = self.combobox_category.get_active()
priority = self.combobox_priority.get_active()
self.combobox_category.set_active(-1)
self.combobox_priority.set_active(-1)
date_formated = date_format(self.calendar.get_date())
data = (text, category, priority, 0, date_formated)
db = DataBase(self.path)
db.add(data)
db.close()
self.get_tasks()
self.mark_day()
class test_database_methods(unittest.TestCase):
def setUp(self):
try:
os.remove(temp_database) # ensure it is not there
except OSError:
pass
self.tmp_db = DataBase(temp_database)
def tearDown(self):
os.remove(temp_database) # cleanup
def test_add_item(self):
id = self.tmp_db.add(user=test_user,
status=test_status,
name=test_name)
entry = self.tmp_db.get(id)
self.assertEqual(entry['nameUser'], test_user)
self.assertEqual(entry['statusItem'], test_status)
self.assertEqual(entry['nameItem'], test_name)
import argparse
from database import DataBase
def get_cmd_args():
parser = argparse.ArgumentParser(
description="Get 'itemname', 'status' and 'user' from user input.")
parser.add_argument('itemname', help='The name of the item to process.')
parser.add_argument('status', help='The status of named item.')
parser.add_argument('user',
help='The user that is responsible for the item.')
args = parser.parse_args()
return args
if __name__ == "__main__":
config = get_cmd_args()
db = DataBase('//home/lidia/git/sis-project/db/db-library.json')
db.add(config.itemname, config.status, config.user)
class TestDB( unittest.TestCase ):
dbData = { 'dir': 'TEST_DIR',
'tags': { 'test_tag_1': 1,
'test tag 2': 2,
'test!/|-@ tag 3': 1,
'тест тэг 4': 4 },
'media': [ { 'file': '1.jpg', 'dir': 'test_content', 'size': 587370, 'created': 1389078966, 'tags': { 'тест тэг 4', 'test!/|-@ tag 3' },
'url': 'http://2.bp.blogspot.com/-722WR2hJZNk/T4HplxWF9WI/AAAAAAAAles/nzwyIIR-If0/s1600/162985+-+artist+john_joseco+cake+celestia.jpg',
'hash': None, 'google': 'princess celestia cake' },
{ 'file': '2.jpg', 'dir': 'test content 2', 'size': 622645, 'created': 1389078965, 'tags': { 'тест тэг 4', 'test_tag_1', 'test tag 2' },
'url': 'http://poniez.net/images/2012/07/16/3Bz2F.jpg',
'hash': None, 'google': 'мир пони' },
{ 'file': '3.jpg', 'dir': 'тест контент 3', 'size': 5784745, 'created': 1389078965, 'tags': { 'тест тэг 4', 'test tag 2' },
'url': 'https://static1.e621.net/TEST_DIR/sample/01/76/017691130342c69beb81ce71e2399df0.jpg',
'hash': None, 'google': 'luna celestia' },
{ 'file': '4.jpg', 'dir': 'unknown dir', 'size': 5784745, 'created': 1389078955, 'tags': { 'тест тэг 4' },
'url': 'https://pp.vk.me/c409823/v409823018/8ad0/9_S0XT7uEcQ.jpg',
'hash': None, 'google': None }
]
}
def setUp( self ):
self.db = DataBase()
self.db.db = deepcopy( self.dbData )
def tearDown( self ):
del self.db
def test_load_db( self ):
with open( 'TEST_DIR/test_db', 'wb' ) as f:
pickle.dump( self.dbData, f )
self.db.load_db( 'xxxxxxxxxxxxxxxxxxxxxxx' )
self.assertEqual( self.db.db, self.db.EMPTY_DB )
self.db.load_db( 'TEST_DIR/test_db' )
self.assertEqual( self.db.db, self.dbData )
os.unlink( 'TEST_DIR/test_db' )
def test_find_file( self ):
self.assertEqual( self.db.find( file = '3.jpg' ), [ self.dbData['media'][2] ] )
def test_find_dir( self ):
self.assertEqual( self.db.find( dir = 'test_content' ), [ self.dbData['media'][0] ] )
def test_find_size( self ):
self.assertEqual( self.db.find( size = 0 ), [] )
def test_find_created( self ):
self.assertEqual( self.db.find( created = 1389078966 ), [ self.dbData['media'][0] ] )
def test_find_tags( self ):
self.assertEqual( self.db.find( tags = {'test tag 2'} ), [ self.dbData['media'][1], self.dbData['media'][2] ] )
def test_find_url_regex( self ):
self.assertEqual( self.db.find( url = r'\.net/', flags = {'re': True} ), [ self.dbData['media'][1], self.dbData['media'][2] ] )
def test_find_hash( self ):
self.assertEqual( self.db.find( hash = None ), [ self.dbData['media'][0], self.dbData['media'][1], self.dbData['media'][2], self.dbData['media'][3] ] )
def test_find_google( self ):
self.assertEqual( self.db.find( google = None ), [ self.dbData['media'][3] ] )
def test_find_both_hash_url( self ):
self.assertEqual( self.db.find( hash = None, url = 'net', flags = {'re': True} ), [ self.dbData['media'][1], self.dbData['media'][2] ] )
def test_add( self ):
self.db.add( file = 'test', hash = 'xxx' )
found = self.db.find( file = 'test' )
self.assertEqual( len( found ), 1 )
self.assertEqual( self.db.db['tags']['Unsorted'], 1 )
self.assertEqual( found[0]['hash'], 'xxx' )
self.assertIn( found[0], self.db.db['media'] )
self.assertEqual( found[0]['created'], None )
def test_add_with_tag( self ):
self.db.add( file = 'test_tag', tags = {'unique_test_tag'} )
self.assertIn( 'unique_test_tag', self.db.find( file = 'test_tag' )[0]['tags'] )
self.assertIn( 'unique_test_tag', self.db.db['tags'] )
self.assertEqual( self.db.db['tags']['unique_test_tag'], 1 )
def test_add_full( self ):
elem = self.dbData['media'][3]
elem['file'] = 'test.png'
self.db.add( **elem )
self.assertEqual( self.db.find( file = 'test.png' ), [elem] )
self.assertEqual( self.db.db['tags']['тест тэг 4'], self.dbData['tags']['тест тэг 4'] + 1 )
def test_remove( self ):
self.assertIn( self.dbData['media'][0], self.db.db['media'] )
self.db.remove( file = '1.jpg' )
self.assertNotIn( self.dbData['media'][0], self.db.db['media'] )
self.assertEqual( self.db.db['tags']['тест тэг 4'], self.dbData['tags']['тест тэг 4'] - 1 )
self.assertNotIn( 'test!/|-@ tag 3', self.db.db['tags'].keys() )
def test_update_file( self ):
self.db.add( file = 'filename', hash = 'xxx' )
self.db.update( {'file': 'filename'}, {'file': 'new_filename', 'hash': 'new'} )
elem = self.db.find( file = 'new_filename', hash = 'new' )
self.assertEqual( len( self.db.find( hash = 'xxx' ) ), 0 )
self.assertEqual( len( elem ), 1 )
self.assertEqual( elem[0]['hash'], 'new' )
def test_update_dir( self ):
self.db.add( file = 'filename_1', dir = 'dir', hash = 'xxx' )
self.db.add( file = 'filename_2', dir = 'dir', hash = 'xxx2' )
self.db.update( {'dir': 'dir'}, {'dir': 'new_dir'} )
elem = self.db.find( dir = 'new_dir' )
self.assertEqual( len( self.db.find( dir = 'dir' ) ), 0 )
self.assertEqual( len( elem ), 2 )
def test_re_flag( self ):
elem = self.db.find( file = '.jpg', flags = { 're': True })
self.assertEqual( len( elem ), 3 )
elem = self.db.find( file = '.jpg', flags = { 're': False })
self.assertEqual( len( elem ), 0 )
elem = self.db.find( file = '.jpg' )
self.assertEqual( len( elem ), 0 )
class Engine( watchdog.events.FileSystemEventHandler ):
#DEFAULT_CFG = [r'D:\disk\Projects\pyMediaMonitor\WATCH_DIR']
DEFAULT_CFG = [r'D:\disk\Pictures\ponies']
DEFAULT_CFG_NAME = 'cfg'
def __init__( self, outFunc = None ):
watchdog.events.FileSystemEventHandler.__init__( self )
if not outFunc:
outFunc = lambda x: True
self.outFunc = outFunc
self.ignoreFiles = []
self.db = DataBase()
self.queue = queue.Queue()
self.worker = threading.Thread( target = self.worker )
def setNotifyOnChange( self, path, isRecursive = False ):
self.observer = watchdog.observers.Observer()
self.observer.schedule( self, path = path, recursive = isRecursive )
self.observer.start()
def loadCfg( self, cfgName = None ):
if not cfgName:
cfgName = self.DEFAULT_CFG_NAME
try:
with open( cfgName, 'rb' ) as f:
self.cfg = pickle.load( f )
except FileNotFoundError:
self.cfg = self.DEFAULT_CFG
def writeCfg( self, cfgName = None ):
if not cfgName:
cfgName = self.DEFAULT_CFG_NAME
with open( cfgName, 'wb' ) as f:
pickle.dump( self.cfg, f )
def run( self ):
self.loadCfg()
self.db.load_db()
self.setNotifyOnChange( self.cfg[0], True )
self.worker.start()
try:
while True:
inp = input()
if inp == 'd':
print( self.db.db )
elif inp == 'u':
self.updateAllInPath( self.cfg[0], self.cfg[0] )
time.sleep( 0.5 )
except KeyboardInterrupt:
self.queue.put( 'quit' )
self.worker.join()
def worker( self ):
while True:
o = self.queue.get( True )
if isinstance( o, str ) and o == 'quit':
break
if len( o ) == 3:
task, query, func = o
elif len( o ) == 2:
task, query = o
func = lambda x: None
else:
raise TypeError( 'Неверный формат задания! Его длина равна {0}.'.format( len( o ) ) )
if func == None:
func = lambda x: None
if task == 'query':
func( self.db.find( **query ) )
def addTask( self, task, resultFunc, **data ):
self.queue.put( ( task, resultFunc, data ) )
def updateAllInPath( self, path, root ):
path = os.path.join( path, '*' )
for f1 in glob.iglob( path ):
if os.path.isdir( f1 ):
path2 = os.path.join( f1, '*' )
for f2 in glob.iglob( path2 ):
if os.path.isdir( f2 ):
self.processEvent( self.prepareEvent( f2, root, Event.ACTION.BROKEN_STRUCTURE ) )
else:
self.processEvent( self.prepareEvent( f2, root, Event.ACTION.NEW ) )
else:
self.processEvent( self.prepareEvent( f1, root, Event.ACTION.NEW ) )
def processEvent( self, event ):
if event.action != Event.ACTION.NOT_PROCESSING and self.outFunc( event ):
if event.action == Event.ACTION.NEW:
self.db.add( file = event.fileName, dir = event.directory, hash = event.info ) # TODO: Делать запрос в гугл ( и другие операции )
elif event.action == Event.ACTION.MISSING:
self.db.remove( file = event.fileName, dir = event.directory )
elif event.action == Event.ACTION.DUPLICATE:
self.ignoreFiles.append( event.path )
os.unlink( event.path )
elif event.action == Event.ACTION.UPDATED:
self.db.update( { 'file': event.fileName, 'dir': event.directory },
{ 'hash': event.info } )
elif event.action == Event.ACTION.RENAMED:
if event.isDir:
self.db.update( { 'dir': event.directory },
{ 'dir': event.info[1] } )
else:
#self.ignoreFiles.append( event.info[0] )
self.db.update( { 'file': event.fileName, 'dir': event.directory },
{ 'file': event.info[0], 'dir': event.info[1] } )
else:
pass
#raise NotImplementedError( 'processEvent called with "{0}"!'.format( event ) )
def prepareEvent( self, path, root, basicAction, info = None ): # Создаем Event
isDir = os.path.isdir( path )
f, d = fileutils.get_file_and_dir( path, root, isDir )
res_path = self.db.find( flags = { 're': False }, file = f, dir = d )
basicEvent = Event( f, d, isDir, root, info )
if len( res_path ) or basicAction == Event.ACTION.RENAMED:
basicEvent.isInDB = True
if not isDir and ( basicAction in (Event.ACTION.MISSING, Event.ACTION.NEW, Event.ACTION.RENAMED, Event.ACTION.UPDATED) ):
if len( res_path ) > 1:
raise RuntimeError( 'В базе данных сразу две записи об одном файле! Нужна полная проверка базы.' )
if os.path.exists( path ):
f_hash = fileutils.get_hash( path )
res_hash = self.db.find( hash = f_hash )
if len( res_path ):
if res_path[0]['hash'] != f_hash: # Файл есть на диске и в базе не совпал хэш.
if basicAction == Event.ACTION.UPDATED:
basicEvent.action = Event.ACTION.UPDATED
basicEvent.info = f_hash
else:
basicEvent.action = Event.ACTION.BAD_HASH # Файл не был модифицирован, а значит это дубль.
basicEvent.info = res_path
elif basicAction == Event.ACTION.RENAMED:
basicEvent.action = basicAction
basicEvent.info = fileutils.get_file_and_dir( info, root, isDir )
elif len( res_hash ): # Файла в базе нет, но есть другой с таким же значением хэша.
basicEvent.isInDB = True
basicEvent.action = Event.ACTION.DUPLICATE
basicEvent.info = res_hash
else:
basicEvent.action = Event.ACTION.NEW # Файл есть над диске, но в базе его нет.
if basicAction == Event.ACTION.RENAMED:
new_f, new_d = fileutils.get_file_and_dir( info, root, isDir )
basicEvent.fileName = new_f
basicEvent.directory = new_d
basicEvent.info = f_hash
elif len( res_path ): # Файла на диске нет, но в базе есть.
basicEvent.action = Event.ACTION.MISSING
else:
basicEvent.action = basicAction
#print( '[EVENT]:', basicEvent )
return basicEvent
def on_any_event( self, event ):
print( event )
info = None
if isinstance( event, watchdog.events.FileCreatedEvent ):
evType = Event.ACTION.NEW
elif isinstance( event, watchdog.events.FileDeletedEvent ):
evType = Event.ACTION.MISSING
elif isinstance( event, watchdog.events.FileMovedEvent ):
evType = Event.ACTION.RENAMED
info = event.dest_path
elif isinstance( event, watchdog.events.FileModifiedEvent ):
evType = Event.ACTION.UPDATED
else:
return
if event.src_path in self.ignoreFiles:
self.ignoreFiles.remove( event.src_path )
return
else:
print( event.src_path, self.ignoreFiles )
self.processEvent( self.prepareEvent( event.src_path, self.cfg[0], evType, info ) )
from database import DataBase
fileName = input('Введите путь к файлу с IDs:\n')
ids = []
with open(fileName, 'r') as f:
ids = f.read().split()
db = DataBase()
for i in range(len(ids)):
print('{} / {}'.format(i, len(ids)), end='\r')
db.add(ids[i])
def add():
data = request.get_json()
db = DataBase()
user_name = data['link'].split('/')[-1]
db.add(user_name)
return jsonify({'success': True})
