riscritto service.py con schedule
This commit is contained in:
marco
Binary file not shown.
+617
@@ -0,0 +1,617 @@
|
||||
"""
|
||||
Python job scheduling for humans.
|
||||
|
||||
github.com/dbader/schedule
|
||||
|
||||
An in-process scheduler for periodic jobs that uses the builder pattern
|
||||
for configuration. Schedule lets you run Python functions (or any other
|
||||
callable) periodically at pre-determined intervals using a simple,
|
||||
human-friendly syntax.
|
||||
|
||||
Inspired by Addam Wiggins' article "Rethinking Cron" [1] and the
|
||||
"clockwork" Ruby module [2][3].
|
||||
|
||||
Features:
|
||||
- A simple to use API for scheduling jobs.
|
||||
- Very lightweight and no external dependencies.
|
||||
- Excellent test coverage.
|
||||
- Tested on Python 2.7, 3.5 and 3.6
|
||||
|
||||
Usage:
|
||||
>>> import schedule
|
||||
>>> import time
|
||||
|
||||
>>> def job(message='stuff'):
|
||||
>>> print("I'm working on:", message)
|
||||
|
||||
>>> schedule.every(10).minutes.do(job)
|
||||
>>> schedule.every(5).to(10).days.do(job)
|
||||
>>> schedule.every().hour.do(job, message='things')
|
||||
>>> schedule.every().day.at("10:30").do(job)
|
||||
|
||||
>>> while True:
|
||||
>>> schedule.run_pending()
|
||||
>>> time.sleep(1)
|
||||
|
||||
[1] https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/
|
||||
[2] https://github.com/Rykian/clockwork
|
||||
[3] https://adam.herokuapp.com/past/2010/6/30/replace_cron_with_clockwork/
|
||||
"""
|
||||
try:
|
||||
from collections.abc import Hashable
|
||||
except ImportError:
|
||||
from collections import Hashable
|
||||
import datetime
|
||||
import functools
|
||||
import logging
|
||||
import random
|
||||
import re
|
||||
import time
|
||||
|
||||
logger = logging.getLogger('schedule')
|
||||
|
||||
|
||||
class ScheduleError(Exception):
|
||||
"""Base schedule exception"""
|
||||
pass
|
||||
|
||||
|
||||
class ScheduleValueError(ScheduleError):
|
||||
"""Base schedule value error"""
|
||||
pass
|
||||
|
||||
|
||||
class IntervalError(ScheduleValueError):
|
||||
"""An improper interval was used"""
|
||||
pass
|
||||
|
||||
|
||||
class CancelJob(object):
|
||||
"""
|
||||
Can be returned from a job to unschedule itself.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class Scheduler(object):
|
||||
"""
|
||||
Objects instantiated by the :class:`Scheduler <Scheduler>` are
|
||||
factories to create jobs, keep record of scheduled jobs and
|
||||
handle their execution.
|
||||
"""
|
||||
def __init__(self):
|
||||
self.jobs = []
|
||||
|
||||
def run_pending(self):
|
||||
"""
|
||||
Run all jobs that are scheduled to run.
|
||||
|
||||
Please note that it is *intended behavior that run_pending()
|
||||
does not run missed jobs*. For example, if you've registered a job
|
||||
that should run every minute and you only call run_pending()
|
||||
in one hour increments then your job won't be run 60 times in
|
||||
between but only once.
|
||||
"""
|
||||
runnable_jobs = (job for job in self.jobs if job.should_run)
|
||||
for job in sorted(runnable_jobs):
|
||||
self._run_job(job)
|
||||
|
||||
def run_all(self, delay_seconds=0):
|
||||
"""
|
||||
Run all jobs regardless if they are scheduled to run or not.
|
||||
|
||||
A delay of `delay` seconds is added between each job. This helps
|
||||
distribute system load generated by the jobs more evenly
|
||||
over time.
|
||||
|
||||
:param delay_seconds: A delay added between every executed job
|
||||
"""
|
||||
logger.info('Running *all* %i jobs with %is delay inbetween',
|
||||
len(self.jobs), delay_seconds)
|
||||
for job in self.jobs[:]:
|
||||
self._run_job(job)
|
||||
time.sleep(delay_seconds)
|
||||
|
||||
def clear(self, tag=None):
|
||||
"""
|
||||
Deletes scheduled jobs marked with the given tag, or all jobs
|
||||
if tag is omitted.
|
||||
|
||||
:param tag: An identifier used to identify a subset of
|
||||
jobs to delete
|
||||
"""
|
||||
if tag is None:
|
||||
del self.jobs[:]
|
||||
else:
|
||||
self.jobs[:] = (job for job in self.jobs if tag not in job.tags)
|
||||
|
||||
def cancel_job(self, job):
|
||||
"""
|
||||
Delete a scheduled job.
|
||||
|
||||
:param job: The job to be unscheduled
|
||||
"""
|
||||
try:
|
||||
self.jobs.remove(job)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
def every(self, interval=1):
|
||||
"""
|
||||
Schedule a new periodic job.
|
||||
|
||||
:param interval: A quantity of a certain time unit
|
||||
:return: An unconfigured :class:`Job <Job>`
|
||||
"""
|
||||
job = Job(interval, self)
|
||||
return job
|
||||
|
||||
def _run_job(self, job):
|
||||
ret = job.run()
|
||||
if isinstance(ret, CancelJob) or ret is CancelJob:
|
||||
self.cancel_job(job)
|
||||
|
||||
@property
|
||||
def next_run(self):
|
||||
"""
|
||||
Datetime when the next job should run.
|
||||
|
||||
:return: A :class:`~datetime.datetime` object
|
||||
"""
|
||||
if not self.jobs:
|
||||
return None
|
||||
return min(self.jobs).next_run
|
||||
|
||||
@property
|
||||
def idle_seconds(self):
|
||||
"""
|
||||
:return: Number of seconds until
|
||||
:meth:`next_run <Scheduler.next_run>`.
|
||||
"""
|
||||
return (self.next_run - datetime.datetime.now()).total_seconds()
|
||||
|
||||
|
||||
class Job(object):
|
||||
"""
|
||||
A periodic job as used by :class:`Scheduler`.
|
||||
|
||||
:param interval: A quantity of a certain time unit
|
||||
:param scheduler: The :class:`Scheduler <Scheduler>` instance that
|
||||
this job will register itself with once it has
|
||||
been fully configured in :meth:`Job.do()`.
|
||||
|
||||
Every job runs at a given fixed time interval that is defined by:
|
||||
|
||||
* a :meth:`time unit <Job.second>`
|
||||
* a quantity of `time units` defined by `interval`
|
||||
|
||||
A job is usually created and returned by :meth:`Scheduler.every`
|
||||
method, which also defines its `interval`.
|
||||
"""
|
||||
def __init__(self, interval, scheduler=None):
|
||||
self.interval = interval # pause interval * unit between runs
|
||||
self.latest = None # upper limit to the interval
|
||||
self.job_func = None # the job job_func to run
|
||||
self.unit = None # time units, e.g. 'minutes', 'hours', ...
|
||||
self.at_time = None # optional time at which this job runs
|
||||
self.last_run = None # datetime of the last run
|
||||
self.next_run = None # datetime of the next run
|
||||
self.period = None # timedelta between runs, only valid for
|
||||
self.start_day = None # Specific day of the week to start on
|
||||
self.tags = set() # unique set of tags for the job
|
||||
self.scheduler = scheduler # scheduler to register with
|
||||
|
||||
def __lt__(self, other):
|
||||
"""
|
||||
PeriodicJobs are sortable based on the scheduled time they
|
||||
run next.
|
||||
"""
|
||||
return self.next_run < other.next_run
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
"Job(interval={}, "
|
||||
"unit={}, "
|
||||
"do={}, "
|
||||
"args={}, "
|
||||
"kwargs={})"
|
||||
).format(self.interval,
|
||||
self.unit,
|
||||
self.job_func.__name__,
|
||||
self.job_func.args,
|
||||
self.job_func.keywords)
|
||||
|
||||
def __repr__(self):
|
||||
def format_time(t):
|
||||
return t.strftime('%Y-%m-%d %H:%M:%S') if t else '[never]'
|
||||
|
||||
def is_repr(j):
|
||||
return not isinstance(j, Job)
|
||||
|
||||
timestats = '(last run: %s, next run: %s)' % (
|
||||
format_time(self.last_run), format_time(self.next_run))
|
||||
|
||||
if hasattr(self.job_func, '__name__'):
|
||||
job_func_name = self.job_func.__name__
|
||||
else:
|
||||
job_func_name = repr(self.job_func)
|
||||
args = [repr(x) if is_repr(x) else str(x) for x in self.job_func.args]
|
||||
kwargs = ['%s=%s' % (k, repr(v))
|
||||
for k, v in self.job_func.keywords.items()]
|
||||
call_repr = job_func_name + '(' + ', '.join(args + kwargs) + ')'
|
||||
|
||||
if self.at_time is not None:
|
||||
return 'Every %s %s at %s do %s %s' % (
|
||||
self.interval,
|
||||
self.unit[:-1] if self.interval == 1 else self.unit,
|
||||
self.at_time, call_repr, timestats)
|
||||
else:
|
||||
fmt = (
|
||||
'Every %(interval)s ' +
|
||||
('to %(latest)s ' if self.latest is not None else '') +
|
||||
'%(unit)s do %(call_repr)s %(timestats)s'
|
||||
)
|
||||
|
||||
return fmt % dict(
|
||||
interval=self.interval,
|
||||
latest=self.latest,
|
||||
unit=(self.unit[:-1] if self.interval == 1 else self.unit),
|
||||
call_repr=call_repr,
|
||||
timestats=timestats
|
||||
)
|
||||
|
||||
@property
|
||||
def second(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use seconds instead of second')
|
||||
return self.seconds
|
||||
|
||||
@property
|
||||
def seconds(self):
|
||||
self.unit = 'seconds'
|
||||
return self
|
||||
|
||||
@property
|
||||
def minute(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use minutes instead of minute')
|
||||
return self.minutes
|
||||
|
||||
@property
|
||||
def minutes(self):
|
||||
self.unit = 'minutes'
|
||||
return self
|
||||
|
||||
@property
|
||||
def hour(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use hours instead of hour')
|
||||
return self.hours
|
||||
|
||||
@property
|
||||
def hours(self):
|
||||
self.unit = 'hours'
|
||||
return self
|
||||
|
||||
@property
|
||||
def day(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use days instead of day')
|
||||
return self.days
|
||||
|
||||
@property
|
||||
def days(self):
|
||||
self.unit = 'days'
|
||||
return self
|
||||
|
||||
@property
|
||||
def week(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use weeks instead of week')
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def weeks(self):
|
||||
self.unit = 'weeks'
|
||||
return self
|
||||
|
||||
@property
|
||||
def monday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use mondays instead of monday')
|
||||
self.start_day = 'monday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def tuesday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use tuesdays instead of tuesday')
|
||||
self.start_day = 'tuesday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def wednesday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use wednesdays instead of wednesday')
|
||||
self.start_day = 'wednesday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def thursday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use thursdays instead of thursday')
|
||||
self.start_day = 'thursday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def friday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use fridays instead of friday')
|
||||
self.start_day = 'friday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def saturday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use saturdays instead of saturday')
|
||||
self.start_day = 'saturday'
|
||||
return self.weeks
|
||||
|
||||
@property
|
||||
def sunday(self):
|
||||
if self.interval != 1:
|
||||
raise IntervalError('Use sundays instead of sunday')
|
||||
self.start_day = 'sunday'
|
||||
return self.weeks
|
||||
|
||||
def tag(self, *tags):
|
||||
"""
|
||||
Tags the job with one or more unique indentifiers.
|
||||
|
||||
Tags must be hashable. Duplicate tags are discarded.
|
||||
|
||||
:param tags: A unique list of ``Hashable`` tags.
|
||||
:return: The invoked job instance
|
||||
"""
|
||||
if not all(isinstance(tag, Hashable) for tag in tags):
|
||||
raise TypeError('Tags must be hashable')
|
||||
self.tags.update(tags)
|
||||
return self
|
||||
|
||||
def at(self, time_str):
|
||||
"""
|
||||
Specify a particular time that the job should be run at.
|
||||
|
||||
:param time_str: A string in one of the following formats: `HH:MM:SS`,
|
||||
`HH:MM`,`:MM`, `:SS`. The format must make sense given how often
|
||||
the job is repeating; for example, a job that repeats every minute
|
||||
should not be given a string in the form `HH:MM:SS`. The difference
|
||||
between `:MM` and `:SS` is inferred from the selected time-unit
|
||||
(e.g. `every().hour.at(':30')` vs. `every().minute.at(':30')`).
|
||||
:return: The invoked job instance
|
||||
"""
|
||||
if (self.unit not in ('days', 'hours', 'minutes')
|
||||
and not self.start_day):
|
||||
raise ScheduleValueError('Invalid unit')
|
||||
if not isinstance(time_str, str):
|
||||
raise TypeError('at() should be passed a string')
|
||||
if self.unit == 'days' or self.start_day:
|
||||
if not re.match(r'^([0-2]\d:)?[0-5]\d:[0-5]\d$', time_str):
|
||||
raise ScheduleValueError('Invalid time format')
|
||||
if self.unit == 'hours':
|
||||
if not re.match(r'^([0-5]\d)?:[0-5]\d$', time_str):
|
||||
raise ScheduleValueError(('Invalid time format for'
|
||||
' an hourly job'))
|
||||
if self.unit == 'minutes':
|
||||
if not re.match(r'^:[0-5]\d$', time_str):
|
||||
raise ScheduleValueError(('Invalid time format for'
|
||||
' a minutely job'))
|
||||
time_values = time_str.split(':')
|
||||
if len(time_values) == 3:
|
||||
hour, minute, second = time_values
|
||||
elif len(time_values) == 2 and self.unit == 'minutes':
|
||||
hour = 0
|
||||
minute = 0
|
||||
_, second = time_values
|
||||
else:
|
||||
hour, minute = time_values
|
||||
second = 0
|
||||
if self.unit == 'days' or self.start_day:
|
||||
hour = int(hour)
|
||||
if not (0 <= hour <= 23):
|
||||
raise ScheduleValueError('Invalid number of hours')
|
||||
elif self.unit == 'hours':
|
||||
hour = 0
|
||||
elif self.unit == 'minutes':
|
||||
hour = 0
|
||||
minute = 0
|
||||
minute = int(minute)
|
||||
second = int(second)
|
||||
self.at_time = datetime.time(hour, minute, second)
|
||||
return self
|
||||
|
||||
def to(self, latest):
|
||||
"""
|
||||
Schedule the job to run at an irregular (randomized) interval.
|
||||
|
||||
The job's interval will randomly vary from the value given
|
||||
to `every` to `latest`. The range defined is inclusive on
|
||||
both ends. For example, `every(A).to(B).seconds` executes
|
||||
the job function every N seconds such that A <= N <= B.
|
||||
|
||||
:param latest: Maximum interval between randomized job runs
|
||||
:return: The invoked job instance
|
||||
"""
|
||||
self.latest = latest
|
||||
return self
|
||||
|
||||
def do(self, job_func, *args, **kwargs):
|
||||
"""
|
||||
Specifies the job_func that should be called every time the
|
||||
job runs.
|
||||
|
||||
Any additional arguments are passed on to job_func when
|
||||
the job runs.
|
||||
|
||||
:param job_func: The function to be scheduled
|
||||
:return: The invoked job instance
|
||||
"""
|
||||
self.job_func = functools.partial(job_func, *args, **kwargs)
|
||||
try:
|
||||
functools.update_wrapper(self.job_func, job_func)
|
||||
except AttributeError:
|
||||
# job_funcs already wrapped by functools.partial won't have
|
||||
# __name__, __module__ or __doc__ and the update_wrapper()
|
||||
# call will fail.
|
||||
pass
|
||||
self._schedule_next_run()
|
||||
self.scheduler.jobs.append(self)
|
||||
return self
|
||||
|
||||
@property
|
||||
def should_run(self):
|
||||
"""
|
||||
:return: ``True`` if the job should be run now.
|
||||
"""
|
||||
return datetime.datetime.now() >= self.next_run
|
||||
|
||||
def run(self):
|
||||
"""
|
||||
Run the job and immediately reschedule it.
|
||||
|
||||
:return: The return value returned by the `job_func`
|
||||
"""
|
||||
logger.info('Running job %s', self)
|
||||
ret = self.job_func()
|
||||
self.last_run = datetime.datetime.now()
|
||||
self._schedule_next_run()
|
||||
return ret
|
||||
|
||||
def _schedule_next_run(self):
|
||||
"""
|
||||
Compute the instant when this job should run next.
|
||||
"""
|
||||
if self.unit not in ('seconds', 'minutes', 'hours', 'days', 'weeks'):
|
||||
raise ScheduleValueError('Invalid unit')
|
||||
|
||||
if self.latest is not None:
|
||||
if not (self.latest >= self.interval):
|
||||
raise ScheduleError('`latest` is greater than `interval`')
|
||||
interval = random.randint(self.interval, self.latest)
|
||||
else:
|
||||
interval = self.interval
|
||||
|
||||
self.period = datetime.timedelta(**{self.unit: interval})
|
||||
self.next_run = datetime.datetime.now() + self.period
|
||||
if self.start_day is not None:
|
||||
if self.unit != 'weeks':
|
||||
raise ScheduleValueError('`unit` should be \'weeks\'')
|
||||
weekdays = (
|
||||
'monday',
|
||||
'tuesday',
|
||||
'wednesday',
|
||||
'thursday',
|
||||
'friday',
|
||||
'saturday',
|
||||
'sunday'
|
||||
)
|
||||
if self.start_day not in weekdays:
|
||||
raise ScheduleValueError('Invalid start day')
|
||||
weekday = weekdays.index(self.start_day)
|
||||
days_ahead = weekday - self.next_run.weekday()
|
||||
if days_ahead <= 0: # Target day already happened this week
|
||||
days_ahead += 7
|
||||
self.next_run += datetime.timedelta(days_ahead) - self.period
|
||||
if self.at_time is not None:
|
||||
if (self.unit not in ('days', 'hours', 'minutes')
|
||||
and self.start_day is None):
|
||||
raise ScheduleValueError(('Invalid unit without'
|
||||
' specifying start day'))
|
||||
kwargs = {
|
||||
'second': self.at_time.second,
|
||||
'microsecond': 0
|
||||
}
|
||||
if self.unit == 'days' or self.start_day is not None:
|
||||
kwargs['hour'] = self.at_time.hour
|
||||
if self.unit in ['days', 'hours'] or self.start_day is not None:
|
||||
kwargs['minute'] = self.at_time.minute
|
||||
self.next_run = self.next_run.replace(**kwargs)
|
||||
# If we are running for the first time, make sure we run
|
||||
# at the specified time *today* (or *this hour*) as well
|
||||
if not self.last_run:
|
||||
now = datetime.datetime.now()
|
||||
if (self.unit == 'days' and self.at_time > now.time() and
|
||||
self.interval == 1):
|
||||
self.next_run = self.next_run - datetime.timedelta(days=1)
|
||||
elif self.unit == 'hours' \
|
||||
and self.at_time.minute > now.minute \
|
||||
or (self.at_time.minute == now.minute
|
||||
and self.at_time.second > now.second):
|
||||
self.next_run = self.next_run - datetime.timedelta(hours=1)
|
||||
elif self.unit == 'minutes' \
|
||||
and self.at_time.second > now.second:
|
||||
self.next_run = self.next_run - \
|
||||
datetime.timedelta(minutes=1)
|
||||
if self.start_day is not None and self.at_time is not None:
|
||||
# Let's see if we will still make that time we specified today
|
||||
if (self.next_run - datetime.datetime.now()).days >= 7:
|
||||
self.next_run -= self.period
|
||||
|
||||
|
||||
# The following methods are shortcuts for not having to
|
||||
# create a Scheduler instance:
|
||||
|
||||
#: Default :class:`Scheduler <Scheduler>` object
|
||||
default_scheduler = Scheduler()
|
||||
|
||||
#: Default :class:`Jobs <Job>` list
|
||||
jobs = default_scheduler.jobs # todo: should this be a copy, e.g. jobs()?
|
||||
|
||||
|
||||
def every(interval=1):
|
||||
"""Calls :meth:`every <Scheduler.every>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
return default_scheduler.every(interval)
|
||||
|
||||
|
||||
def run_pending():
|
||||
"""Calls :meth:`run_pending <Scheduler.run_pending>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
default_scheduler.run_pending()
|
||||
|
||||
|
||||
def run_all(delay_seconds=0):
|
||||
"""Calls :meth:`run_all <Scheduler.run_all>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
default_scheduler.run_all(delay_seconds=delay_seconds)
|
||||
|
||||
|
||||
def clear(tag=None):
|
||||
"""Calls :meth:`clear <Scheduler.clear>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
default_scheduler.clear(tag)
|
||||
|
||||
|
||||
def cancel_job(job):
|
||||
"""Calls :meth:`cancel_job <Scheduler.cancel_job>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
default_scheduler.cancel_job(job)
|
||||
|
||||
|
||||
def next_run():
|
||||
"""Calls :meth:`next_run <Scheduler.next_run>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
return default_scheduler.next_run
|
||||
|
||||
|
||||
def idle_seconds():
|
||||
"""Calls :meth:`idle_seconds <Scheduler.idle_seconds>` on the
|
||||
:data:`default scheduler instance <default_scheduler>`.
|
||||
"""
|
||||
return default_scheduler.idle_seconds
|
||||
@@ -189,29 +189,7 @@ def get_all_settings_addon():
|
||||
|
||||
|
||||
def open_settings():
|
||||
settings_pre = get_all_settings_addon()
|
||||
__settings__.openSettings()
|
||||
settings_post = get_all_settings_addon()
|
||||
|
||||
from specials import videolibrary
|
||||
from platformcode import xbmc_videolibrary
|
||||
if settings_pre.get('downloadpath', None) != settings_post.get('downloadpath', None):
|
||||
xbmc_videolibrary.update_sources(settings_post.get('downloadpath', None), settings_pre.get('downloadpath', None))
|
||||
|
||||
# si se ha cambiado la ruta de la videoteca llamamos a comprobar directorios para que lo cree y pregunte
|
||||
# automaticamente si configurar la videoteca
|
||||
if settings_pre.get("videolibrarypath", None) != settings_post.get("videolibrarypath", None) or \
|
||||
settings_pre.get("folder_movies", None) != settings_post.get("folder_movies", None) or \
|
||||
settings_pre.get("folder_tvshows", None) != settings_post.get("folder_tvshows", None):
|
||||
videolibrary.move_videolibrary(settings_pre.get("videolibrarypath", None), settings_post.get("videolibrarypath", None),
|
||||
settings_pre.get("folder_movies", None), settings_post.get("folder_movies", None),
|
||||
settings_pre.get("folder_tvshows", None), settings_post.get("folder_tvshows", None))
|
||||
|
||||
# si se ha puesto que se quiere autoconfigurar y se había creado el directorio de la videoteca
|
||||
if not settings_pre.get("videolibrary_kodi", None) and settings_post.get("videolibrary_kodi", None):
|
||||
xbmc_videolibrary.ask_set_content(silent=True)
|
||||
elif settings_pre.get("videolibrary_kodi", None) and not settings_post.get("videolibrary_kodi", None):
|
||||
xbmc_videolibrary.clean()
|
||||
|
||||
|
||||
def get_setting(name, channel="", server="", default=None):
|
||||
|
||||
@@ -5928,7 +5928,7 @@ msgid "Logging"
|
||||
msgstr ""
|
||||
|
||||
msgctxt "#70789"
|
||||
msgid "* Change by opening the settings from KoD main menu"
|
||||
msgid ""
|
||||
msgstr ""
|
||||
|
||||
msgctxt "#70790"
|
||||
|
||||
@@ -5928,8 +5928,8 @@ msgid "Logging"
|
||||
msgstr "Logging"
|
||||
|
||||
msgctxt "#70789"
|
||||
msgid "* Change by opening the settings from KoD main menu"
|
||||
msgstr "* Cambia aprendo le impostazioni dal menu principale di KoD"
|
||||
msgid ""
|
||||
msgstr ""
|
||||
|
||||
msgctxt "#70790"
|
||||
msgid "RAR download in progress"
|
||||
|
||||
@@ -33,7 +33,6 @@
|
||||
<setting id="folder_tvshows" type="text" label="70118" default="Serie TV"/>
|
||||
<setting id="folder_movies" type="text" label="70119" default="Film"/>
|
||||
<setting id="videolibrary_kodi" type="bool" label="70120" default="false"/>
|
||||
<setting id="settings_kod" type="action" label="70789" action=""/>
|
||||
<setting label="59997" type="lsep"/>
|
||||
<setting id="videolibrary_max_quality" type="bool" label="70729" default="false" visible="true"/>
|
||||
<setting id="next_ep" type="select" label="70746" lvalues="70752|70747|70748" default="0"/>
|
||||
@@ -95,7 +94,6 @@
|
||||
<category label="30153">
|
||||
<setting id="downloadenabled" type="bool" label="70689" default="false"/>
|
||||
<setting id="downloadpath" type="folder" label="30017" visible="eq(-1,true)" default="special://profile/addon_data/plugin.video.kod/downloads/" option="writeable"/>
|
||||
<setting id="settings_kod1" type="action" label="70789" action="" visible="eq(-2,true)"/>
|
||||
<!-- <setting id="library_add" type="bool" label="70230" default="false"/>
|
||||
<setting id="library_move" type="bool" label="70231" default="false" visible="eq(-1,true)" subsetting="true"/> -->
|
||||
<setting id="downloadlistpath" type="folder" label="30018" visible="eq(-3,true)" default="special://profile/addon_data/plugin.video.kod/downloads/list/" option="writeable"/>
|
||||
|
||||
+119
-161
@@ -1,26 +1,20 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# ------------------------------------------------------------
|
||||
# Service for updating new episodes on library series
|
||||
# ------------------------------------------------------------
|
||||
|
||||
import datetime, imp, math, threading, traceback, sys, glob, time
|
||||
|
||||
import datetime
|
||||
import math
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import traceback
|
||||
import xbmc
|
||||
import xbmcgui
|
||||
from platformcode import config
|
||||
try:
|
||||
import xbmc, os
|
||||
librerias = xbmc.translatePath(os.path.join(config.get_runtime_path(), 'lib'))
|
||||
sys.path.append(librerias)
|
||||
except:
|
||||
import os
|
||||
librerias = os.path.join(config.get_runtime_path(), 'lib')
|
||||
sys.path.append(librerias)
|
||||
librerias = xbmc.translatePath(os.path.join(config.get_runtime_path(), 'lib'))
|
||||
sys.path.insert(0, librerias)
|
||||
|
||||
|
||||
from core import channeltools, filetools, videolibrarytools
|
||||
from platformcode import logger
|
||||
from platformcode import platformtools
|
||||
from core import videolibrarytools, filetools, channeltools
|
||||
from lib import schedule
|
||||
from platformcode import logger, platformtools, updater
|
||||
from specials import videolibrary
|
||||
from platformcode import updater
|
||||
|
||||
|
||||
def update(path, p_dialog, i, t, serie, overwrite):
|
||||
@@ -61,7 +55,8 @@ def update(path, p_dialog, i, t, serie, overwrite):
|
||||
if serie.library_filter_show:
|
||||
serie.show = serie.library_filter_show.get(serie.channel, serie.contentSerieName)
|
||||
|
||||
obj = imp.load_source(serie.channel, pathchannels)
|
||||
obj = __import__('channels.%s' % serie.channel, fromlist=[pathchannels])
|
||||
|
||||
itemlist = obj.episodios(serie)
|
||||
|
||||
try:
|
||||
@@ -261,104 +256,13 @@ def check_for_update(overwrite=True):
|
||||
videolibrary.list_movies(item_dummy, silent=True)
|
||||
|
||||
|
||||
def start(thread=True):
|
||||
if thread:
|
||||
t = threading.Thread(target=start, args=[False])
|
||||
t.setDaemon(True)
|
||||
t.start()
|
||||
else:
|
||||
import time
|
||||
|
||||
update_wait = [0, 10000, 20000, 30000, 60000]
|
||||
wait = update_wait[int(config.get_setting("update_wait", "videolibrary"))]
|
||||
if wait > 0:
|
||||
time.sleep(wait)
|
||||
|
||||
if not config.get_setting("update", "videolibrary") == 2:
|
||||
check_for_update(overwrite=False)
|
||||
|
||||
# Se ejecuta ciclicamente
|
||||
while True:
|
||||
monitor_update()
|
||||
time.sleep(3600) # cada hora
|
||||
|
||||
|
||||
def monitor_update():
|
||||
update_setting = config.get_setting("update", "videolibrary")
|
||||
|
||||
# "Actualizar "Una sola vez al dia" o "al inicar Kodi y al menos una vez al dia"
|
||||
|
||||
if update_setting == 2 or update_setting == 3:
|
||||
hoy = datetime.date.today()
|
||||
last_check = config.get_setting("updatelibrary_last_check", "videolibrary")
|
||||
if last_check:
|
||||
y, m, d = last_check.split('-')
|
||||
last_check = datetime.date(int(y), int(m), int(d))
|
||||
else:
|
||||
last_check = hoy - datetime.timedelta(days=1)
|
||||
|
||||
update_start = config.get_setting("everyday_delay", "videolibrary") * 4
|
||||
|
||||
# logger.info("Ultima comprobacion: %s || Fecha de hoy:%s || Hora actual: %s" %
|
||||
# (last_check, hoy, datetime.datetime.now().hour))
|
||||
# logger.info("Atraso del inicio del dia: %i:00" % update_start)
|
||||
|
||||
if last_check <= hoy and datetime.datetime.now().hour == int(update_start):
|
||||
logger.info("Inicio actualizacion programada para las %s h.: %s" % (update_start, datetime.datetime.now()))
|
||||
check_for_update(overwrite=False)
|
||||
|
||||
if not config.dev_mode():
|
||||
period = float(config.get_setting('addon_update_timer')) * 3600
|
||||
curTime = time.time()
|
||||
lastCheck = config.get_setting("updater_last_check", "videolibrary", '0')
|
||||
if lastCheck:
|
||||
lastCheck = float(lastCheck)
|
||||
else:
|
||||
lastCheck = 0
|
||||
|
||||
if curTime - lastCheck > period:
|
||||
updated, needsReload = updater.check(background=True)
|
||||
config.set_setting("updater_last_check", str(curTime), "videolibrary")
|
||||
if needsReload:
|
||||
xbmc.executescript(__file__)
|
||||
exit(0)
|
||||
|
||||
# always bypass al websites that use cloudflare at startup, so there's no need to wait 5 seconds when opened
|
||||
def callCloudflare():
|
||||
from core import httptools, support
|
||||
import json
|
||||
channels_path = os.path.join(config.get_runtime_path(), "channels", '*.json')
|
||||
channel_files = [os.path.splitext(os.path.basename(c))[0] for c in glob.glob(channels_path)]
|
||||
for channel_name in channel_files:
|
||||
channel_parameters = channeltools.get_channel_parameters(channel_name)
|
||||
if 'cloudflare' in channel_parameters and channel_parameters["cloudflare"]:
|
||||
channel = __import__('channels.%s' % channel_name, fromlist=["channels.%s" % channel_name])
|
||||
try:
|
||||
channel.findhost()
|
||||
except:
|
||||
pass
|
||||
httptools.downloadpage(channel.host)
|
||||
|
||||
servers_path = os.path.join(config.get_runtime_path(), "servers", '*.json')
|
||||
servers_files = glob.glob(servers_path)
|
||||
for server in servers_files:
|
||||
with open(server) as server:
|
||||
server_parameters = json.load(server)
|
||||
if 'cloudflare' in server_parameters and server_parameters["cloudflare"]:
|
||||
patternUrl = server_parameters["find_videos"]["patterns"][0]["url"]
|
||||
url = '/'.join(patternUrl.split('/')[:3])
|
||||
httptools.downloadpage(url)
|
||||
|
||||
|
||||
def viewmodeMonitor(monitor):
|
||||
import xbmcgui
|
||||
while not monitor.abortRequested():
|
||||
time.sleep(0.5)
|
||||
def viewmodeMonitor():
|
||||
try:
|
||||
currentModeName = xbmc.getInfoLabel('Container.Viewmode')
|
||||
win = xbmcgui.Window(xbmcgui.getCurrentWindowId())
|
||||
currentMode = int(win.getFocusId())
|
||||
if currentModeName and 'plugin.video.kod' in xbmc.getInfoLabel('Container.FolderPath') and currentMode < 1000 and currentMode > 50: # inside addon and in itemlist view
|
||||
if currentModeName and 'plugin.video.kod' in xbmc.getInfoLabel(
|
||||
'Container.FolderPath') and currentMode < 1000 and currentMode > 50: # inside addon and in itemlist view
|
||||
content, Type = platformtools.getCurrentView()
|
||||
defaultMode = int(config.get_setting('view_mode_%s' % content).split(',')[-1])
|
||||
if currentMode != defaultMode:
|
||||
@@ -368,59 +272,113 @@ def viewmodeMonitor(monitor):
|
||||
logger.error(traceback.print_exc())
|
||||
|
||||
|
||||
def updaterCheck():
|
||||
# updater check
|
||||
updated, needsReload = updater.check(background=True)
|
||||
if needsReload:
|
||||
xbmc.executescript(__file__)
|
||||
exit(0)
|
||||
|
||||
|
||||
def run_threaded(job_func, args):
|
||||
job_thread = threading.Thread(target=job_func, args=args)
|
||||
job_thread.start()
|
||||
|
||||
|
||||
class AddonMonitor(xbmc.Monitor):
|
||||
def __init__(self):
|
||||
self.settings_pre = config.get_all_settings_addon()
|
||||
|
||||
self.updaterPeriod = None
|
||||
self.update_setting = None
|
||||
self.update_hour = None
|
||||
self.scheduleUpdater()
|
||||
|
||||
# videolibrary wait
|
||||
update_wait = [0, 10000, 20000, 30000, 60000]
|
||||
wait = update_wait[int(config.get_setting("update_wait", "videolibrary"))]
|
||||
if wait > 0:
|
||||
xbmc.sleep(wait)
|
||||
if not config.get_setting("update", "videolibrary") == 2:
|
||||
check_for_update(overwrite=False)
|
||||
run_threaded(check_for_update, (False,))
|
||||
self.scheduleVideolibrary()
|
||||
super(AddonMonitor, self).__init__()
|
||||
|
||||
def onSettingsChanged(self):
|
||||
logger.info('settings changed')
|
||||
settings_post = config.get_all_settings_addon()
|
||||
from platformcode import xbmc_videolibrary
|
||||
|
||||
if self.settings_pre.get('downloadpath', None) != settings_post.get('downloadpath', None):
|
||||
xbmc_videolibrary.update_sources(settings_post.get('downloadpath', None),
|
||||
self.settings_pre.get('downloadpath', None))
|
||||
|
||||
# si se ha cambiado la ruta de la videoteca llamamos a comprobar directorios para que lo cree y pregunte
|
||||
# automaticamente si configurar la videoteca
|
||||
if self.settings_pre.get("videolibrarypath", None) != settings_post.get("videolibrarypath", None) or \
|
||||
self.settings_pre.get("folder_movies", None) != settings_post.get("folder_movies", None) or \
|
||||
self.settings_pre.get("folder_tvshows", None) != settings_post.get("folder_tvshows", None):
|
||||
videolibrary.move_videolibrary(self.settings_pre.get("videolibrarypath", None),
|
||||
settings_post.get("videolibrarypath", None),
|
||||
self.settings_pre.get("folder_movies", None),
|
||||
settings_post.get("folder_movies", None),
|
||||
self.settings_pre.get("folder_tvshows", None),
|
||||
settings_post.get("folder_tvshows", None))
|
||||
|
||||
# si se ha puesto que se quiere autoconfigurar y se había creado el directorio de la videoteca
|
||||
if not self.settings_pre.get("videolibrary_kodi", None) and settings_post.get("videolibrary_kodi", None):
|
||||
xbmc_videolibrary.ask_set_content(silent=True)
|
||||
elif self.settings_pre.get("videolibrary_kodi", None) and not settings_post.get("videolibrary_kodi", None):
|
||||
xbmc_videolibrary.clean()
|
||||
|
||||
if self.settings_pre.get('addon_update_timer') != settings_post.get('addon_update_timer'):
|
||||
schedule.clear('updater')
|
||||
self.scheduleUpdater()
|
||||
|
||||
if self.update_setting != config.get_setting("update", "videolibrary") or self.update_hour != config.get_setting("everyday_delay", "videolibrary") * 4:
|
||||
schedule.clear('videolibrary')
|
||||
self.scheduleVideolibrary()
|
||||
|
||||
self.settings_pre = settings_post
|
||||
|
||||
def onScreensaverActivated(self):
|
||||
logger.info('screensaver activated, un-scheduling screen-on jobs')
|
||||
schedule.clear('screenOn')
|
||||
|
||||
def onScreensaverDeactivated(self):
|
||||
logger.info('screensaver deactivated, re-scheduling screen-on jobs')
|
||||
schedule.every().second.do(viewmodeMonitor).tag('screenOn')
|
||||
|
||||
def scheduleUpdater(self):
|
||||
if not config.dev_mode():
|
||||
updaterCheck()
|
||||
self.updaterPeriod = float(config.get_setting('addon_update_timer')) * 3600
|
||||
schedule.every(self.updaterPeriod).hour.do(updaterCheck).tag('updater')
|
||||
logger.info('scheduled updater every ' + str(self.updaterPeriod) + ' hours')
|
||||
|
||||
def scheduleVideolibrary(self):
|
||||
self.update_setting = config.get_setting("update", "videolibrary")
|
||||
# 2= daily 3=daily and when kodi starts
|
||||
if self.update_setting == 2 or self.update_setting == 3:
|
||||
self.update_hour = config.get_setting("everyday_delay", "videolibrary") * 4
|
||||
schedule.every().day.at(str(self.update_hour).zfill(2) + ':00').do(run_threaded, check_for_update, (False,)).tag('videolibrary')
|
||||
logger.info('scheduled videolibrary at ' + str(self.update_hour).zfill(2) + ':00')
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# threading.Thread(target=callCloudflare())
|
||||
# Se ejecuta en cada inicio
|
||||
import xbmc
|
||||
import time
|
||||
logger.info('Starting KoD service')
|
||||
monitor = AddonMonitor()
|
||||
|
||||
# mark as stopped all downloads (if we are here, probably kodi just started)
|
||||
from specials.downloads import stop_all
|
||||
stop_all()
|
||||
|
||||
update_wait = [0, 10000, 20000, 30000, 60000]
|
||||
wait = update_wait[int(config.get_setting("update_wait", "videolibrary"))]
|
||||
if wait > 0:
|
||||
xbmc.sleep(wait)
|
||||
# other things
|
||||
schedule.every().second.do(viewmodeMonitor).tag('screenOn')
|
||||
|
||||
while True:
|
||||
schedule.run_pending()
|
||||
|
||||
# Verificar quick-fixes al abrirse Kodi, y dejarlo corriendo como Thread
|
||||
if not config.dev_mode():
|
||||
updated, needsReload = updater.check(background=True)
|
||||
config.set_setting("updater_last_check", str(time.time()), "videolibrary")
|
||||
if needsReload:
|
||||
xbmc.executescript(__file__)
|
||||
exit(0)
|
||||
|
||||
# Copia Custom code a las carpetas de Alfa desde la zona de Userdata
|
||||
# from platformcode import custom_code
|
||||
# custom_code.init()
|
||||
from threading import Thread
|
||||
Thread(target=viewmodeMonitor).start()
|
||||
from servers import torrent
|
||||
Thread(target=torrent.elementum_monitor).start()
|
||||
|
||||
if not config.get_setting("update", "videolibrary") == 2:
|
||||
check_for_update(overwrite=False)
|
||||
|
||||
|
||||
# Se ejecuta ciclicamente
|
||||
if config.get_platform(True)['num_version'] >= 14:
|
||||
monitor = xbmc.Monitor() # For Kodi >= 14
|
||||
else:
|
||||
monitor = None # For Kodi < 14
|
||||
|
||||
from threading import Thread
|
||||
|
||||
Thread(target=viewmodeMonitor, args=(monitor,)).start()
|
||||
|
||||
if monitor:
|
||||
while not monitor.abortRequested():
|
||||
monitor_update()
|
||||
if monitor.waitForAbort(3600): # cada hora
|
||||
if monitor.waitForAbort(1): # every second
|
||||
break
|
||||
else:
|
||||
while not xbmc.abortRequested:
|
||||
monitor_update()
|
||||
xbmc.sleep(3600)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user