piexel/piexel-indexer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Tout modifié pour la nouvelle API

Browse source
This commit is contained in:
redstorm45 2017-10-29 20:58:32 +01:00
parent d1de6ffe09
commit cb4ea4d419
5 changed files with 86 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

52
file.py
View file

@ -1,21 +1,16 @@
#coding:utf-8
import posixpath
import re
class File:
"""
Décrit une référence de fichier dans le disque
"""
def __init__(self, path, name,api_id=None):
def __init__(self, path, name, info, api_id=None):
self.path = path
self.name = name
self.fullname = path+name
'''
self.info_lang = []
self.info_quality = []
self.info_subtitles = []
self.title = ''
self.simple_name = self.title.replace(' ', '')
'''
self.info = info
self.markers = {}
self.api_id = api_id
def get_ext(self):
@ -23,37 +18,46 @@ class File:
return ext
def without_ext(self):
_, ext = posixpath.splitext(self.name)
return ext
n, ext = posixpath.splitext(self.name)
return n
def _extract_title(self, title, tok):
def extract_title(self, tok):
# extrait un titre de film depuis la variable #TITLE#
fname, ext = posixpath.splitext(title)
if 'TITLE' in self.info:
fname = self.info['TITLE']
else:
fname, ext = posixpath.splitext(self.name)
# 1) séparateurs
fname = fname.replace('.', ' ')
fname = fname.replace('_', ' ')
fname = fname.replace('-', ' ')
# 2) marqueurs
fname, info = tok.tokenize(fname)
self.markers = info
# 3) minuscule
fname = fname.lower()
# 4) année
if self.year is not None:
fname = fname.replace('['+str(self.year)+']', '')
fname = fname.replace('[ '+str(self.year)+' ]', '')
fname = fname.replace('['+str(self.year)+' ]', '')
fname = fname.replace('[ '+str(self.year)+']', '')
if not 'YEAR' in self.info:
m = re.match(r'.*\[ ?(\d{4}) ?\].*', fname)
if m:
self.info['YEAR'] = m.group(1)
if 'YEAR' in self.info:
year = self.info['YEAR']
fname = fname.replace('['+str(year)+']', '')
fname = fname.replace('[ '+str(year)+' ]', '')
fname = fname.replace('['+str(year)+' ]', '')
fname = fname.replace('[ '+str(year)+']', '')
# 5) espaces en bout, centraux et rajoutés
fname = fname.lstrip().rstrip()
while ' ' in fname:
fname = fname.replace(' ', ' ')
return fname
self.title = fname
def filename_same(self, other):
# Compare les noms de fichiers de self et de other
# En supprimant les espaces, la date, et les marques de qualitée
return self.simple_name == other.simple_name
return self.name == other.name
'''
def additional_info(self):
"""
Info supplémentaires sur la langue, la qualitée et les sous-titres du fichier
@ -87,7 +91,7 @@ class File:
if m in self.info_subtitles:
info['subtitles'] = 'EN'
return info
'''
def __eq__(self, other):
return (self.path, self.name) == (other.path, other.name)
@ -95,7 +99,9 @@ class File:
return hash((self.path, self.name))
def __str__(self):
return str(self.path+'/'+self.name+' year:['+str(self.year)+']')
if 'YEAR' in self.info:
return str(self.path+'/'+self.name+' year:['+str(self.info['YEAR'])+']')
return str(self.path+'/'+self.name)
def __repr__(self):
return str(self)

12
filerule.py
View file

@ -1,5 +1,6 @@
import re
PATTERN_BASIC = re.compile(r'#(.+?)#')
def match_rules(filename, rules):
for r in rules:
@ -11,17 +12,18 @@ def match_rules(filename, rules):
class FileRule:
def __init__(self, rule, conf):
# trouve les marqueurs dans la règle
reg = re.compile(r'#(.+?)#')
self.patterns = reg.findall(rule)
rg = reg.sub(lambda m:self.regFor(match=m, conf=conf), rule)
self.rule = re.compile(rg)
print(self.patterns, self.rule)
self.patterns = PATTERN_BASIC.findall(rule)
rg = PATTERN_BASIC.sub(lambda m:self.regFor(match=m, conf=conf), rule)
self.rule = re.compile(rg) # on garde la version compilée (donc optimisée)
@staticmethod
def regFor(match, conf):
name = match.group(0)
trunc_name = name[1:-1]
if name == '#EXT#':
return '('+'|'.join(conf.extensions)+')'
elif name in ['#EPISODE_NUM#', '#SEASON_NUM#']:
return '([0-9]+)'
return '([^/]+)'
def apply(self, filename):

41
main.py
View file

@ -42,7 +42,7 @@ def ftpwalk(directory, ftp):
# mais retourne les résultats intermédiaires
yield (current, Ldirs, Lfiles)
def visit_folder(domain, api, rules):
def visit_folder(domain, api, rules, tok):
# Connection au serveur
print('connect to:', domain['server'])
ftp = FTP(domain['server'][6:], user=domain['username'], passwd=domain['password'])
@ -58,21 +58,33 @@ def visit_folder(domain, api, rules):
for f in files:
match = filerule.match_rules(path+'/'+f, rules)
if match:
print('got match:',match[1], 'name:',path+'/'+f)
F = file.File(path+'/'+f, match[1])
#print('got match:',match[1], 'name:',path+'/'+f)
F = file.File(path, f, match[1])
F.extract_title(tok)
Lloc.append(F)
ftp.close()
print('total:',len(Lloc))
exit(0)
# Application des règles de chemins
# Récupère les fichiers de l'api
Lapi = []
for info in api.get_files(path='ftp://'+domain['server']+domain['path'], like=1):
Lapi.append(file.File(info['path'][len('ftp://'+domain['server']):], info['name'], api_id=info['filable_id']))
for info in api.get_files(path=domain['server']+domain['path'], like=1, filable=1):
nfo = {}
if not info['filable']:
print('nfo:', info)
else:
year = int(info['filable']['release_date'][:4])
nfo['YEAR'] = year
F = file.File(info['path'][len(domain['server']):], info['name'], nfo, api_id=info['filable_id'])
F.extract_title(tok)
Lapi.append(F)
print('got api for ',domain['server']+domain['path'],':', len(Lapi))
print('loc titles:', '|'.join(sorted([f.title for f in Lloc])))
print('\n'*2)
print('api titles:', '|'.join(sorted([f.title for f in Lapi])))
return
# supprime les dossiers de l'api
Lapi = [f for f in Lapi if conf.is_valid_file(f.name)]
Lapi = [f for f in Lapi if tok.conf.is_valid_file(f.name)]
# Compare avec la liste de l'api
Lmissing = [f for f in Lapi if f not in Lloc] # fichiers non présents localement
@ -117,19 +129,20 @@ def visit_folder(domain, api, rules):
Llink2 = []
for film in Lunref:
for title, fid in API_alltitles:
if title==film.simple_name:
if title==film.title:
Llink2.append((film, fid))
break
#print(film, ' <-> ', [f for f in APIfilms if f['id']==fid][0]['title'])
print('easy ref:', sorted(Llink2, key=lambda f:str(f)))
for f, _ in Llink2:
Lunref.remove(f)
print('missing:',[str(e.api_id)+':'+repr(e) for e in Lmissing])
print('missing (', len(Lmissing), '):',[str(e.api_id)+':'+repr(e) for e in Lmissing])
print('\n'*3)
print('unreferenced:','\n'.join(str(f) for f in Lunref))
print('unreferenced:','|'.join(str(f) for f in Lunref))
print('\n'*3)
print('unreferenced titles:', '\n'.join(sorted([f.title for f in Lunref])))
print('unreferenced titles:', '|'.join(sorted([f.title for f in Lunref])))
'''
# Put les renommages / déplacements
i = 0
@ -222,7 +235,7 @@ def main():
for fold in folders:
applicable = [filerule.FileRule(re.escape(fold['path'])+'\\/'+r['regex'], conf) for r in rules if int(r['indexer_folder_id']) == fold['id']]
visit_folder(fold, api, applicable)
visit_folder(fold, api, applicable, tokens)
if __name__ == '__main__':
main()

53
piexel.py
View file

@ -1,5 +1,6 @@
#coding:utf-8
import requests
from requests.auth import HTTPBasicAuth
class PiexelErrors(Exception):
pass
@ -15,8 +16,9 @@ class InvalidResponse(PiexelErrors):
class Piexel:
def __init__(self, domain, app='', token='', endpoint='/api/'):
self.app = app
self.token = token
#self.app = app
#self.token = token
self.auth = HTTPBasicAuth(app, token)
self.domain = domain
self.endpoint = endpoint
@ -26,23 +28,24 @@ class Piexel:
:param controller: controller à utiliser
:param fields: champ à passer
"""
fields['app'] = self.app
fields['token'] = self.token
#fields['app'] = self.app
#fields['token'] = self.token
#fields['auth'] = self.auth
url = self.domain + self.endpoint + controller
if request_type == 'get':
response = requests.get(url, fields)
response = requests.get(url, auth=self.auth, params=fields)
elif request_type == 'post':
response = requests.post(url, fields)
response = requests.post(url, auth=self.auth, params=fields)
elif request_type == 'put':
response = requests.put(url, fields)
response = requests.put(url, auth=self.auth, params=fields)
elif request_type == 'delete':
response = requests.delete(url, data=fields)
response = requests.delete(url, auth=self.auth, data=fields)
response.encoding = 'utf-8'
code = response.status_code
try:
data = response.json()
except:
raise InvalidResponse(response.text)
raise InvalidResponse(url, fields, response.text)
if code == 403: # FORBIDDEN
raise InvalidToken(data['message'])
elif code == 400:
@ -110,14 +113,6 @@ class Piexel:
fields = self._get_request([], [], **params)
return self._get_response('indexer/paths', fields)
def get_actors(self, **params):
"""
Récupère les acteurs
:param params: paramètres à passer
"""
fields = self._get_request(['id', 'name', 'imdb_id', 'tmdb_id', 'limit', 'first', 'films', 'series'], [], **params)
return self._get_response('actors', fields)
def get_files(self, **params):
"""
Récupère les fichiers
@ -182,14 +177,6 @@ class Piexel:
fields = self._get_request(['season', 'episode', 'serie_id'], ['season', 'episode', 'serie_id'], **params)
return self._get_response('episodes', fields, 'post')
def post_actor(self, **params):
"""
Ajoute un acteur
:param params: paramètres à passer
"""
fields = self._get_request(['name'], ['name'], **params)
return self._get_response('episodes', fields, 'post')
def post_broken(self, **params):
"""
Ajoute un lien mort
@ -238,14 +225,6 @@ class Piexel:
fields = self._get_request(['id', 'title', 'serid_id', 'tmdb_id', 'summary', 'cover_img', 'season', 'episode', 'rating', 'release_date'], ['id'], **params)
return self._get_response('episodes', fields, 'put')
def put_actor(self, **params):
"""
Edite un acteur
:param params: paramètres à passer
"""
fields = self._get_request(['id', 'name', 'imdb_id', 'tmdb_id', 'cover_img'], ['id'], **params)
return self._get_response('actors', fields, 'put')
def put_broken(self, **params):
"""
Edite un lien mort
@ -294,14 +273,6 @@ class Piexel:
fields = self._get_request(['id'], ['id'], **params)
return self._get_response('episodes', fields, 'delete')
def delete_actor(self, **params):
"""
Supprime un acteur
:param params: paramètres à passer
"""
fields = self._get_request(['id'], ['id'], **params)
return self._get_response('actors', fields, 'delete')
def delete_broken(self, **params):
"""
Supprime un lien mort

23
tokenizer.py
View file

@ -2,7 +2,6 @@
import piexel
import re
class Tokenizer:
def __init__(self, conf, api):
self.conf = conf
@ -17,22 +16,22 @@ class Tokenizer:
def get_tokens_step(self, step):
return [t for t in self.tk if t['step'] == step]
def tokenise(self, filename):
found = {}
def tokenize(self, filename):
found = {'lang':[], 'quality':[], 'subtitle':[]}
for step in self.steps:
for tok in self.get_tokens_step(step):
if(not bool(tk['case_sensitive'])):
if(not bool(int(tok['case_sensitive']))):
reg = re.compile(tok['token'], re.IGNORECASE)
else:
reg = re.compile(tok['token'])
if reg.match(filename):
if(tok['lang']):
found['lang'] = tok['lang']
if(tok['quality']):
found['quality'] = tok['quality']
if(tok['subtitle']):
found['subtitles'] = tok['subtitle']
reg.sub(' ', filename)
if reg.search(filename):
for tok_lang in tok['languages']:
found['lang'].append(tok_lang['value'])
for tok_qual in tok['qualities']:
found['quality'].append(tok_qual['value'])
for tok_sub in tok['subtitle_languages']:
found['subtitle'].append(tok_sub['value'])
filename = reg.sub(' ', filename)
return filename, found