'
-import time, os, cPickle
-from PyQt4.QtCore import SIGNAL, QUrl
-from PyQt4.QtGui import QDesktopServices
+import time, os
+
+from PyQt4.Qt import SIGNAL, QUrl, QDesktopServices, QAbstractListModel, Qt, \
+ QVariant, QInputDialog
from calibre.web.feeds.recipes import compile_recipe
from calibre.web.feeds.news import AutomaticNewsRecipe
from calibre.gui2.dialogs.user_profiles_ui import Ui_Dialog
from calibre.gui2 import qstring_to_unicode, error_dialog, question_dialog, \
- choose_files, ResizableDialog
+ choose_files, ResizableDialog, NONE
from calibre.gui2.widgets import PythonHighlighter
from calibre.ptempfile import PersistentTemporaryFile
+class CustomRecipeModel(QAbstractListModel):
+
+ def __init__(self, recipe_model):
+ QAbstractListModel.__init__(self)
+ self.recipe_model = recipe_model
+
+ def title(self, index):
+ row = index.row()
+ if row > -1 and row < self.rowCount():
+ return self.recipe_model.custom_recipe_collection[row].get('title', '')
+
+ def script(self, index):
+ row = index.row()
+ if row > -1 and row < self.rowCount():
+ urn = self.recipe_model.custom_recipe_collection[row].get('id')
+ return self.recipe_model.get_recipe(urn)
+
+ def has_title(self, title):
+ for x in self.recipe_model.custom_recipe_collection:
+ if x.get('title', False) == title:
+ return True
+ return False
+
+ def rowCount(self, *args):
+ return len(self.recipe_model.custom_recipe_collection)
+
+ def data(self, index, role):
+ if role == Qt.DisplayRole:
+ ans = self.title(index)
+ if ans is not None:
+ return QVariant(ans)
+ return NONE
+
+ def replace_by_title(self, title, script):
+ urn = None
+ for x in self.recipe_model.custom_recipe_collection:
+ if x.get('title', False) == title:
+ urn = x.get('id')
+ if urn is not None:
+ self.recipe_model.update_custom_recipe(urn, title, script)
+ self.reset()
+
+ def add(self, title, script):
+ self.recipe_model.add_custom_recipe(title, script)
+ self.reset()
+
+ def remove(self, rows):
+ urns = []
+ for r in rows:
+ try:
+ urn = self.recipe_model.custom_recipe_collection[r].get('id')
+ urns.append(urn)
+ except:
+ pass
+ self.recipe_model.remove_custom_recipes(urns)
+ self.reset()
+
class UserProfiles(ResizableDialog, Ui_Dialog):
- def __init__(self, parent, feeds):
+ def __init__(self, parent, recipe_model):
ResizableDialog.__init__(self, parent)
+ self._model = self.model = CustomRecipeModel(recipe_model)
+ self.available_profiles.setModel(self._model)
+ self.available_profiles.currentChanged = self.current_changed
+
self.connect(self.remove_feed_button, SIGNAL('clicked(bool)'),
self.added_feeds.remove_selected_items)
self.connect(self.remove_profile_button, SIGNAL('clicked(bool)'),
- self.available_profiles.remove_selected_items)
+ self.remove_selected_items)
self.connect(self.add_feed_button, SIGNAL('clicked(bool)'),
self.add_feed)
self.connect(self.load_button, SIGNAL('clicked()'), self.load)
@@ -33,13 +95,16 @@ class UserProfiles(ResizableDialog, Ui_Dialog):
self.add_profile)
self.connect(self.feed_url, SIGNAL('returnPressed()'), self.add_feed)
self.connect(self.feed_title, SIGNAL('returnPressed()'), self.add_feed)
- self.connect(self.available_profiles,
- SIGNAL('currentItemChanged(QListWidgetItem*, QListWidgetItem*)'),
- self.edit_profile)
self.connect(self.toggle_mode_button, SIGNAL('clicked(bool)'), self.toggle_mode)
self.clear()
- for title, src in feeds:
- self.available_profiles.add_item(title, (title, src), replace=True)
+
+ def break_cycles(self):
+ self.recipe_model = self._model.recipe_model = None
+
+ def remove_selected_items(self):
+ indices = self.available_profiles.selectionModel().selectedRows()
+ self._model.remove([i.row() for i in indices])
+ self.clear()
def up(self):
row = self.added_feeds.currentRow()
@@ -56,12 +121,11 @@ class UserProfiles(ResizableDialog, Ui_Dialog):
self.added_feeds.setCurrentItem(item)
def share(self):
- row = self.available_profiles.currentRow()
- item = self.available_profiles.item(row)
- if item is None:
+ index = self.available_profiles.currentIndex()
+ title, src = self._model.title(index), self._model.script(index)
+ if not title or not src:
error_dialog(self, _('No recipe selected'), _('No recipe selected')).exec_()
return
- title, src = item.user_data
pt = PersistentTemporaryFile(suffix='.py')
pt.write(src.encode('utf-8'))
pt.close()
@@ -74,10 +138,11 @@ class UserProfiles(ResizableDialog, Ui_Dialog):
QDesktopServices.openUrl(url)
- def edit_profile(self, current, previous):
- if not current:
- current = previous
- src = current.user_data[1]
+ def current_changed(self, current, previous):
+ if not current.isValid(): return
+ src = self._model.script(current)
+ if src is None:
+ return
if 'class BasicUserRecipe' in src:
recipe = compile_recipe(src)
self.populate_options(recipe)
@@ -172,72 +237,64 @@ class %(classname)s(%(base_class)s):
_('Could not create recipe. Error:
%s')%str(err)).exec_()
return
profile = src.replace('BasicUserRecipe', 'AdvancedUserRecipe')
- try:
- self.available_profiles.add_item(title, (title, profile), replace=False)
- except ValueError:
+ if self._model.has_title(title):
if question_dialog(self, _('Replace recipe?'),
_('A custom recipe named %s already exists. Do you want to '
'replace it?')%title):
- self.available_profiles.add_item(title, (title, profile), replace=True)
+ self._model.replace_by_title(title, profile)
else:
return
+ else:
+ self.model.add(title, profile)
self.clear()
def add_builtin_recipe(self):
- from calibre.web.feeds.recipes import recipes, recipe_modules, english_sort
- from PyQt4.Qt import QInputDialog
+ from calibre.web.feeds.recipes.collection import \
+ get_builtin_recipe_by_title, get_builtin_recipe_titles
+ items = get_builtin_recipe_titles()
- rdat = cPickle.load(open(P('recipes.pickle'), 'rb'))
- class Recipe(object):
- def __init__(self, title, id, recipes):
- self.title = unicode(title)
- self.id = id
- self.text = recipes[id]
- def __cmp__(self, other):
- return english_sort(self.title, other.title)
-
- recipes = sorted([Recipe(r.title, i, rdat) for r, i in zip(recipes, recipe_modules)])
- items = [r.title for r in recipes]
title, ok = QInputDialog.getItem(self, _('Pick recipe'), _('Pick the recipe to customize'),
items, 0, False)
if ok:
title = unicode(title)
- for r in recipes:
- if r.title == title:
- try:
- self.available_profiles.add_item(title, (title, r.text), replace=False)
- except ValueError:
- if question_dialog(self, _('Replace recipe?'),
- _('A custom recipe named %s already exists. Do you '
- 'want to replace it?')%title):
- self.available_profiles.add_item(title, (title, r.text), replace=True)
- else:
- return
- self.clear()
- break
+ profile = get_builtin_recipe_by_title(title)
+ if self._model.has_title(title):
+ if question_dialog(self, _('Replace recipe?'),
+ _('A custom recipe named %s already exists. Do you want to '
+ 'replace it?')%title):
+ self._model.replace_by_title(title, profile)
+ else:
+ return
+ else:
+ self.model.add(title, profile)
+
+ self.clear()
def load(self):
- files = choose_files(self, 'recipe loader dialog', _('Choose a recipe file'), filters=[(_('Recipes'), '*.py')], all_files=False, select_only_single_file=True)
+ files = choose_files(self, 'recipe loader dialog',
+ _('Choose a recipe file'),
+ filters=[(_('Recipes'), ['.py', '.recipe'])],
+ all_files=False, select_only_single_file=True)
if files:
file = files[0]
try:
- src = open(file, 'rb').read().decode('utf-8')
- title = compile_recipe(src).title
+ profile = open(file, 'rb').read().decode('utf-8')
+ title = compile_recipe(profile).title
except Exception, err:
error_dialog(self, _('Invalid input'),
_('
Could not create recipe. Error:
%s')%str(err)).exec_()
return
- try:
- self.available_profiles.add_item(title, (title, src), replace=False)
- except ValueError:
+ if self._model.has_title(title):
if question_dialog(self, _('Replace recipe?'),
_('A custom recipe named %s already exists. Do you want to '
'replace it?')%title):
- self.available_profiles.add_item(title, (title, src), replace=True)
+ self._model.replace_by_title(title, profile)
else:
return
+ else:
+ self.model.add(title, profile)
self.clear()
def populate_options(self, profile):
@@ -256,8 +313,11 @@ class %(classname)s(%(base_class)s):
self.populate_options(AutomaticNewsRecipe)
self.source_code.setText('')
- def profiles(self):
- for i in self.available_profiles.items():
- yield i.user_data
-
+if __name__ == '__main__':
+ from PyQt4.Qt import QApplication
+ QApplication([])
+ from calibre.library.database2 import LibraryDatabase2
+ from calibre.web.feeds.recipes.model import RecipeModel
+ d=UserProfiles(None, RecipeModel(LibraryDatabase2('/home/kovid/documents/library')))
+ d.exec_()
diff --git a/src/calibre/gui2/dialogs/user_profiles.ui b/src/calibre/gui2/dialogs/user_profiles.ui
index 64b6d10123..48f92a108c 100644
--- a/src/calibre/gui2/dialogs/user_profiles.ui
+++ b/src/calibre/gui2/dialogs/user_profiles.ui
@@ -34,8 +34,8 @@
0
0
- 720
- 586
+ 730
+ 600
@@ -46,7 +46,7 @@
- 680
+ 580
550
@@ -58,7 +58,7 @@
- 0
+ 1
0
@@ -67,14 +67,7 @@
-
-
-
-
- 0
- 0
-
-
-
+
-
@@ -136,6 +129,12 @@
-
+
+
+ 10
+ 0
+
+
QFrame::StyledPanel
diff --git a/src/calibre/gui2/library.py b/src/calibre/gui2/library.py
index cc3fcb3f7d..147c2780c5 100644
--- a/src/calibre/gui2/library.py
+++ b/src/calibre/gui2/library.py
@@ -222,8 +222,8 @@ class BooksModel(QAbstractTableModel):
self.count_changed()
return ret
- def add_news(self, path, recipe):
- ret = self.db.add_news(path, recipe)
+ def add_news(self, path, arg):
+ ret = self.db.add_news(path, arg)
self.count_changed()
return ret
diff --git a/src/calibre/gui2/main.py b/src/calibre/gui2/main.py
index 06e7749fad..1e06f2eb0c 100644
--- a/src/calibre/gui2/main.py
+++ b/src/calibre/gui2/main.py
@@ -518,10 +518,17 @@ class Main(MainWindow, Ui_MainWindow, DeviceGUI):
self.test_server_timer = QTimer.singleShot(10000, self.test_server)
- self.scheduler = Scheduler(self)
+ self.scheduler = Scheduler(self, self.library_view.model().db)
self.action_news.setMenu(self.scheduler.news_menu)
self.connect(self.action_news, SIGNAL('triggered(bool)'),
self.scheduler.show_dialog)
+ self.connect(self.scheduler, SIGNAL('delete_old_news(PyQt_PyObject)'),
+ self.library_view.model().delete_books_by_id,
+ Qt.QueuedConnection)
+ self.connect(self.scheduler,
+ SIGNAL('start_recipe_fetch(PyQt_PyObject)'),
+ self.download_scheduled_recipe, Qt.QueuedConnection)
+
self.location_view.setCurrentIndex(self.location_view.model().index(0))
def resizeEvent(self, ev):
@@ -1155,27 +1162,27 @@ class Main(MainWindow, Ui_MainWindow, DeviceGUI):
############################### Fetch news #################################
- def download_scheduled_recipe(self, recipe, script, callback):
+ def download_scheduled_recipe(self, arg):
func, args, desc, fmt, temp_files = \
- fetch_scheduled_recipe(recipe, script)
+ fetch_scheduled_recipe(arg)
job = self.job_manager.run_job(
Dispatcher(self.scheduled_recipe_fetched), func, args=args,
description=desc)
- self.conversion_jobs[job] = (temp_files, fmt, recipe, callback)
- self.status_bar.showMessage(_('Fetching news from ')+recipe.title, 2000)
+ self.conversion_jobs[job] = (temp_files, fmt, arg)
+ self.status_bar.showMessage(_('Fetching news from ')+arg['title'], 2000)
def scheduled_recipe_fetched(self, job):
- temp_files, fmt, recipe, callback = self.conversion_jobs.pop(job)
+ temp_files, fmt, arg = self.conversion_jobs.pop(job)
pt = temp_files[0]
if job.failed:
return self.job_exception(job)
- id = self.library_view.model().add_news(pt.name, recipe)
+ id = self.library_view.model().add_news(pt.name, arg)
self.library_view.model().reset()
sync = dynamic.get('news_to_be_synced', set([]))
sync.add(id)
dynamic.set('news_to_be_synced', sync)
- callback(recipe)
- self.status_bar.showMessage(recipe.title + _(' fetched.'), 3000)
+ self.scheduler.recipe_downloaded(arg)
+ self.status_bar.showMessage(arg['title'] + _(' fetched.'), 3000)
self.email_news(id)
self.sync_news()
diff --git a/src/calibre/gui2/tools.py b/src/calibre/gui2/tools.py
index 525efec25b..f6431581b5 100644
--- a/src/calibre/gui2/tools.py
+++ b/src/calibre/gui2/tools.py
@@ -207,8 +207,7 @@ class QueueBulk(QProgressDialog):
self.jobs.reverse()
self.queue(self.jobs, self.changed, self.bad, *self.args)
-def fetch_scheduled_recipe(recipe, script):
- from calibre.gui2.dialogs.scheduler import config
+def fetch_scheduled_recipe(arg):
from calibre.ebooks.conversion.config import load_defaults
fmt = prefs['output_format'].lower()
pt = PersistentTemporaryFile(suffix='_recipe_out.%s'%fmt.lower())
@@ -228,16 +227,14 @@ def fetch_scheduled_recipe(recipe, script):
recs.append(('header', True, OptionRecommendation.HIGH))
recs.append(('header_format', '%t', OptionRecommendation.HIGH))
- args = [script, pt.name, recs]
- if recipe.needs_subscription:
- x = config.get('recipe_account_info_%s'%recipe.id, False)
- if not x:
- raise ValueError(_('You must set a username and password for %s')%recipe.title)
- recs.append(('username', x[0], OptionRecommendation.HIGH))
- recs.append(('password', x[1], OptionRecommendation.HIGH))
+ args = [arg['recipe'], pt.name, recs]
+ if arg['username'] is not None:
+ recs.append(('username', arg['username'], OptionRecommendation.HIGH))
+ if arg['password'] is not None:
+ recs.append(('password', arg['password'], OptionRecommendation.HIGH))
- return 'gui_convert', args, _('Fetch news from ')+recipe.title, fmt.upper(), [pt]
+ return 'gui_convert', args, _('Fetch news from ')+arg['title'], fmt.upper(), [pt]
def convert_existing(parent, db, book_ids, output_format):
already_converted_ids = []
diff --git a/src/calibre/library/database.py b/src/calibre/library/database.py
index e04df68949..cfd2213eed 100644
--- a/src/calibre/library/database.py
+++ b/src/calibre/library/database.py
@@ -8,7 +8,6 @@ import datetime, re, cPickle, sre_constants
from zlib import compress, decompress
from calibre.ebooks.metadata import MetaInformation
-from calibre.web.feeds.recipes import migrate_automatic_profile_to_automatic_recipe
from calibre.ebooks.metadata import string_to_authors
class Concatenate(object):
@@ -739,10 +738,7 @@ ALTER TABLE books ADD COLUMN isbn TEXT DEFAULT "" COLLATE NOCASE;
@staticmethod
def upgrade_version8(conn):
- feeds = conn.execute('SELECT title, script FROM feeds').fetchall()
- for title, script in feeds:
- script = migrate_automatic_profile_to_automatic_recipe(script)
- conn.execute('UPDATE feeds SET script=? WHERE title=?', (script, title))
+ conn.execute('DELETE FROM feeds')
conn.execute('pragma user_version=9')
conn.commit()
@@ -1363,6 +1359,26 @@ ALTER TABLE books ADD COLUMN isbn TEXT DEFAULT "" COLLATE NOCASE;
for title, script in feeds:
yield title, script
+ def get_feed(self, id):
+ return self.conn.get('SELECT script FROM feeds WHERE id=%d'%id,
+ all=False)
+
+ def update_feed(self, id, script, title):
+ self.conn.execute('UPDATE feeds set title=? WHERE id=?', (title, id))
+ self.conn.execute('UPDATE feeds set script=? WHERE id=?', (script, id))
+ self.conn.commit()
+
+ def remove_feeds(self, ids):
+ for x in ids:
+ self.conn.execute('DELETE FROM feeds WHERE id=?', (x,))
+ self.conn.commit()
+
+ def add_feed(self, title, script):
+ self.conn.execute('INSERT INTO feeds(title, script) VALUES (?, ?)',
+ (title, script))
+ self.conn.commit()
+
+
def set_feeds(self, feeds):
self.conn.execute('DELETE FROM feeds')
for title, script in feeds:
diff --git a/src/calibre/library/database2.py b/src/calibre/library/database2.py
index 44685aa8aa..6cdcd631bc 100644
--- a/src/calibre/library/database2.py
+++ b/src/calibre/library/database2.py
@@ -1323,14 +1323,18 @@ class LibraryDatabase2(LibraryDatabase):
if notify:
self.notify('metadata', [id])
- def add_news(self, path, recipe):
+ def add_news(self, path, arg):
format = os.path.splitext(path)[1][1:].lower()
stream = path if hasattr(path, 'read') else open(path, 'rb')
stream.seek(0)
mi = get_metadata(stream, format, use_libprs_metadata=False)
stream.seek(0)
mi.series_index = 1.0
- mi.tags = [_('News'), recipe.title]
+ mi.tags = [_('News')]
+ if arg['add_title_tag']:
+ mi.tags += [arg['title']]
+ if arg['custom_tags']:
+ mi.tags += arg['custom_tags']
obj = self.conn.execute('INSERT INTO books(title, author_sort) VALUES (?, ?)',
(mi.title, mi.authors[0]))
id = obj.lastrowid
@@ -1696,6 +1700,11 @@ books_series_link feeds
return duplicates
+ def get_custom_recipes(self):
+ for id, title, script in self.conn.get('SELECT id,title,script FROM feeds'):
+ yield id, title, script
+
+
def check_integrity(self, callback):
callback(0., _('Checking SQL integrity...'))
user_version = self.user_version
diff --git a/src/calibre/web/feeds/input.py b/src/calibre/web/feeds/input.py
index 39f7be154f..adad69f885 100644
--- a/src/calibre/web/feeds/input.py
+++ b/src/calibre/web/feeds/input.py
@@ -43,14 +43,15 @@ class RecipeInput(InputFormatPlugin):
def convert(self, recipe_or_file, opts, file_ext, log,
accelerators):
- from calibre.web.feeds.recipes import \
- get_builtin_recipe, compile_recipe
+ from calibre.web.feeds.recipes import compile_recipe
+ from calibre.web.feeds.recipes.collection import \
+ get_builtin_recipe_by_title
if os.access(recipe_or_file, os.R_OK):
recipe = compile_recipe(open(recipe_or_file, 'rb').read())
else:
title = getattr(opts, 'original_recipe_input_arg', recipe_or_file)
title = os.path.basename(title).rpartition('.')[0]
- recipe = get_builtin_recipe(title)
+ recipe = compile_recipe(get_builtin_recipe_by_title(title, log))
if recipe is None:
raise ValueError('%r is not a valid recipe file or builtin recipe' %
diff --git a/src/calibre/web/feeds/recipes/__init__.py b/src/calibre/web/feeds/recipes/__init__.py
index fe8ae80997..fb83fa04b3 100644
--- a/src/calibre/web/feeds/recipes/__init__.py
+++ b/src/calibre/web/feeds/recipes/__init__.py
@@ -4,95 +4,15 @@ __copyright__ = '2008, Kovid Goyal '
'''
Builtin recipes.
'''
-recipe_modules = ['recipe_' + r for r in (
- 'newsweek', 'atlantic', 'economist', 'portfolio', 'the_register',
- 'usatoday', 'bbc', 'greader', 'wsj', #'outlook_india',
- 'wired', 'globe_and_mail', 'smh', 'espn', 'business_week', 'miami_herald',
- 'ars_technica', 'upi', 'new_yorker', 'irish_times', 'lanacion',
- 'discover_magazine', 'scientific_american', 'new_york_review_of_books',
- 'daily_telegraph', 'guardian', 'el_pais', 'new_scientist', 'b92',
- 'politika', 'moscow_times', 'latimes', 'japan_times', 'san_fran_chronicle',
- 'demorgen_be', 'de_standaard', 'ap', 'barrons', 'chr_mon', 'cnn', 'faznet',
- 'jpost', 'jutarnji', 'nasa', 'reuters', 'spiegelde', 'wash_post', 'zeitde',
- 'blic', 'novosti', 'danas', 'vreme', 'times_online', 'the_scotsman',
- 'nytimes_sub', 'nytimes', 'security_watch', 'cyberpresse', 'st_petersburg_times',
- 'clarin', 'financial_times', 'heise', 'le_monde', 'harpers', 'science_aas',
- 'science_news', 'the_nation', 'lrb', 'harpers_full', 'liberation',
- 'linux_magazine', 'telegraph_uk', 'utne', 'sciencedaily', 'forbes',
- 'time_magazine', 'endgadget', 'fudzilla', 'nspm_int', 'nspm', 'pescanik',
- 'spiegel_int', 'themarketticker', 'tomshardware', 'xkcd', 'ftd', 'zdnet',
- 'joelonsoftware', 'telepolis', 'common_dreams', 'nin', 'tomshardware_de',
- 'pagina12', 'infobae', 'ambito', 'elargentino', 'sueddeutsche', 'the_age',
- 'laprensa', 'amspec', 'freakonomics', 'criticadigital', 'elcronista',
- 'shacknews', 'teleread', 'granma', 'juventudrebelde', 'juventudrebelde_english',
- 'la_tercera', 'el_mercurio_chile', 'la_cuarta', 'lanacion_chile', 'la_segunda',
- 'jb_online', 'estadao', 'o_globo', 'vijesti', 'elmundo', 'the_oz',
- 'honoluluadvertiser', 'starbulletin', 'exiled', 'indy_star', 'dna',
- 'pobjeda', 'chicago_breaking_news', 'glasgow_herald', 'linuxdevices',
- 'hindu', 'cincinnati_enquirer', 'physics_world', 'pressonline',
- 'la_republica', 'physics_today', 'chicago_tribune', 'e_novine',
- 'al_jazeera', 'winsupersite', 'borba', 'courrierinternational',
- 'lamujerdemivida', 'soldiers', 'theonion', 'news_times',
- 'el_universal', 'mediapart', 'wikinews_en', 'ecogeek', 'daily_mail',
- 'new_york_review_of_books_no_sub', 'politico', 'adventuregamers',
- 'mondedurable', 'instapaper', 'dnevnik_cro', 'vecernji_list',
- 'nacional_cro', '24sata', 'dnevni_avaz', 'glas_srpske', '24sata_rs',
- 'krstarica', 'krstarica_en', 'tanjug', 'laprensa_ni', 'azstarnet',
- 'corriere_della_sera_it', 'corriere_della_sera_en', 'msdnmag_en',
- 'moneynews', 'der_standard', 'diepresse', 'nzz_ger', 'hna',
- 'seattle_times', 'scott_hanselman', 'coding_horror', 'twitchfilms',
- 'stackoverflow', 'telepolis_artikel', 'zaobao', 'usnews',
- 'straitstimes', 'index_hu', 'pcworld_hu', 'hrt', 'rts', 'axxon_news',
- 'h1', 'h2', 'h3', 'phd_comics', 'woz_die', 'elektrolese',
- 'climate_progress', 'carta', 'slashdot', 'publico',
- 'the_budget_fashionista', 'elperiodico_catalan',
- 'elperiodico_spanish', 'expansion_spanish', 'lavanguardia',
- 'marca', 'kellog_faculty', 'kellog_insight', 'noaa',
- '7dias', 'buenosaireseconomico', 'huntechnet', 'cubadebate',
- 'diagonales', 'miradasalsur', 'newsweek_argentina', 'veintitres',
- 'gva_be', 'hln', 'tijd', 'degentenaar', 'inquirer_net', 'uncrate',
- 'fastcompany', 'accountancyage', 'laprensa_hn', 'latribuna',
- 'eltiempo_hn', 'slate', 'tnxm', 'bbcvietnamese', 'vnexpress',
- 'volksrant', 'theeconomictimes_india', 'ourdailybread',
- 'monitor', 'republika', 'beta', 'beta_en', 'glasjavnosti',
- 'esquire', 'livemint', 'thedgesingapore', 'darknet', 'rga',
- 'intelligencer', 'theoldfoodie', 'hln_be', 'honvedelem',
- 'the_new_republic', 'philly', 'salon', 'tweakers', 'smashing',
- 'thestar', 'business_standard', 'lemonde_dip', 'javalobby',
- 'serverside', 'infoworld', 'sanjosemercurynews', 'businessworldin',
- )]
-
-
import re, imp, inspect, time, os
from calibre.web.feeds.news import BasicNewsRecipe, CustomIndexRecipe, AutomaticNewsRecipe
from calibre.ebooks.BeautifulSoup import BeautifulSoup
from calibre.ptempfile import PersistentTemporaryDirectory
from calibre import __appname__, english_sort
+BeautifulSoup, time, english_sort
+
basic_recipes = (BasicNewsRecipe, AutomaticNewsRecipe, CustomIndexRecipe)
-basic_recipe_names = (i.__name__ for i in basic_recipes)
-
-
-#: Compile builtin recipe/profile classes
-def load_recipe(module, package='calibre.web.feeds.recipes'):
- module = __import__(package+'.'+module, fromlist=[''])
- for attr in dir(module):
- obj = getattr(module, attr)
- if type(obj) is not type:
- continue
- recipe = False
- for b in obj.__bases__:
- if b in basic_recipes:
- recipe = True
- break
- if not recipe:
- continue
- if obj not in basic_recipes:
- return obj
-
-
-recipes = [load_recipe(i) for i in recipe_modules]
-
_tdir = None
_crep = 0
def compile_recipe(src):
@@ -133,40 +53,3 @@ def compile_recipe(src):
return classes[0][1]
-def get_builtin_recipe(title):
- '''
- Return a builtin recipe/profile class whose title == C{title} or None if no such
- recipe exists.
-
- @type title: string
- @rtype: class or None
- '''
- for r in recipes:
- if r.title == title:
- return r
- return None
-
-_titles = [r.title for r in recipes]
-_titles.sort(cmp=english_sort)
-titles = _titles
-
-def migrate_automatic_profile_to_automatic_recipe(profile):
- BeautifulSoup
- oprofile = profile
- profile = compile_recipe(profile)
- if 'BasicUserProfile' not in profile.__name__:
- return oprofile
- return '''\
-class BasicUserRecipe%d(AutomaticNewsRecipe):
-
- title = %s
- oldest_article = %d
- max_articles_per_feed = %d
- summary_length = %d
-
- feeds = %s
-
-'''%(int(time.time()), repr(profile.title), profile.oldest_article,
- profile.max_articles_per_feed, profile.summary_length, repr(profile.feeds))
-
-
diff --git a/src/calibre/web/feeds/recipes/collection.py b/src/calibre/web/feeds/recipes/collection.py
new file mode 100644
index 0000000000..852325f706
--- /dev/null
+++ b/src/calibre/web/feeds/recipes/collection.py
@@ -0,0 +1,331 @@
+#!/usr/bin/env python
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+from __future__ import with_statement
+
+__license__ = 'GPL v3'
+__copyright__ = '2009, Kovid Goyal '
+__docformat__ = 'restructuredtext en'
+
+import os, calendar
+from threading import RLock
+from datetime import datetime, timedelta
+
+from lxml import etree
+from lxml.builder import ElementMaker
+from dateutil import parser
+
+NS = 'http://calibre-ebook.com/recipe_collection'
+E = ElementMaker(namespace=NS, nsmap={None:NS})
+
+def iterate_over_builtin_recipe_files():
+ exclude = ['craigslist', 'iht', 'le_temps', 'outlook_india', 'toronto_sun']
+ d = os.path.dirname
+ base = os.path.join(d(d(d(d(d(d(os.path.abspath(__file__))))))), 'resources', 'recipes')
+ for x in os.walk(base):
+ for f in x[-1]:
+ fbase, ext = os.path.splitext(f)
+ if ext != '.recipe' or fbase in exclude:
+ continue
+ f = os.path.join(x[0], f)
+ rid = os.path.splitext(os.path.relpath(f, base).replace(os.sep,
+ '/'))[0]
+ yield rid, os.path.join(x[0], f)
+
+
+def serialize_recipe(urn, recipe_class):
+
+ def attr(n, d):
+ ans = getattr(recipe_class, n, d)
+ if isinstance(ans, str):
+ ans = ans.decode('utf-8', 'replace')
+ return ans
+
+ default_author = _('You') if urn.startswith('custom:') else _('Unknown')
+ return E.recipe({
+ 'id' : str(urn),
+ 'title' : attr('title', _('Unknown')),
+ 'author' : attr('__author__', default_author),
+ 'language' : attr('language', 'und'),
+ 'needs_subscription' : 'yes' if attr('needs_subscription', False) else 'no',
+ 'description' : attr('description', '')
+ })
+
+def serialize_collection(mapping_of_recipe_classes):
+ collection = E.recipe_collection()
+ for urn, recipe_class in mapping_of_recipe_classes.items():
+ recipe = serialize_recipe(urn, recipe_class)
+ collection.append(recipe)
+ collection.set('count', str(len(collection)))
+ return etree.tostring(collection, encoding='utf-8', xml_declaration=True,
+ pretty_print=True)
+
+def serialize_builtin_recipes():
+ from calibre.web.feeds.recipes import compile_recipe
+ recipe_mapping = {}
+ for rid, f in iterate_over_builtin_recipe_files():
+ recipe_class = compile_recipe(open(f, 'rb').read())
+ if recipe_class is not None:
+ recipe_mapping['builtin:'+rid] = recipe_class
+
+ return serialize_collection(recipe_mapping)
+
+def get_builtin_recipe_collection():
+ return etree.parse(P('builtin_recipes.xml')).getroot()
+
+def get_custom_recipe_collection(db):
+ from calibre.web.feeds.recipes import compile_recipe
+ rmap = {}
+ for id, title, recipe in db.get_custom_recipes():
+ try:
+ recipe_class = compile_recipe(recipe)
+ if recipe_class is not None:
+ rmap['custom:%d'%id] = recipe_class
+ except:
+ continue
+
+ return etree.fromstring(serialize_collection(rmap))
+
+def get_builtin_recipe_titles():
+ return [r.get('title') for r in get_builtin_recipe_collection()]
+
+def get_builtin_recipe_by_title(title, log=None):
+ for x in get_builtin_recipe_collection():
+ if x.get('title') == title:
+ urn = x.get('id')[8:]
+ return P('recipes/%s.recipe'%urn, data=True)
+
+class SchedulerConfig(object):
+
+ def __init__(self):
+ from calibre.utils.config import config_dir
+ from calibre.utils.lock import ExclusiveFile
+ self.conf_path = os.path.join(config_dir, 'scheduler.xml')
+ old_conf_path = os.path.join(config_dir, 'scheduler.pickle')
+ self.root = E.recipe_collection()
+ self.lock = RLock()
+ if os.access(self.conf_path, os.R_OK):
+ with ExclusiveFile(self.conf_path) as f:
+ self.root = etree.fromstring(f.read())
+ elif os.path.exists(old_conf_path):
+ self.migrate_old_conf(old_conf_path)
+
+ def iter_recipes(self):
+ for x in self.root:
+ if x.tag == '{%s}scheduled_recipe'%NS:
+ yield x
+
+ def iter_accounts(self):
+ for x in self.root:
+ if x.tag == '{%s}account_info'%NS:
+ yield x
+
+ def iter_customization(self):
+ for x in self.root:
+ if x.tag == '{%s}recipe_customization'%NS:
+ yield x
+
+ def schedule_recipe(self, recipe, schedule_type, schedule, last_downloaded=None):
+ with self.lock:
+ for x in list(self.iter_recipes()):
+ if x.get('id', False) == recipe.get('id'):
+ ld = x.get('last_downloaded', None)
+ if ld and last_downloaded is None:
+ try:
+ last_downloaded = parser.parse(ld)
+ except:
+ pass
+ self.root.remove(x)
+ break
+ if last_downloaded is None:
+ last_downloaded = datetime.fromordinal(1)
+ sr = E.scheduled_recipe({
+ 'id' : recipe.get('id'),
+ 'title': recipe.get('title'),
+ 'last_downloaded':last_downloaded.isoformat(),
+ }, self.serialize_schedule(schedule_type, schedule))
+ self.root.append(sr)
+ self.write_scheduler_file()
+
+ def customize_recipe(self, urn, add_title_tag, custom_tags):
+ with self.lock:
+ for x in list(self.iter_customization()):
+ if x.get('id') == urn:
+ self.root.remove(x)
+ cs = E.recipe_customization({
+ 'id' : urn,
+ 'add_title_tag' : 'yes' if add_title_tag else 'no',
+ 'custom_tags' : ','.join(custom_tags),
+ })
+ self.root.append(cs)
+ self.write_scheduler_file()
+
+ def un_schedule_recipe(self, recipe_id):
+ with self.lock:
+ for x in list(self.iter_recipes()):
+ if x.get('id', False) == recipe_id:
+ self.root.remove(x)
+ break
+ self.write_scheduler_file()
+
+ def update_last_downloaded(self, recipe_id):
+ with self.lock:
+ now = datetime.utcnow()
+ for x in self.iter_recipes():
+ if x.get('id', False) == recipe_id:
+ typ, sch, last_downloaded = self.un_serialize_schedule(x)
+ if typ == 'interval':
+ actual_interval = now - last_downloaded
+ nominal_interval = timedelta(days=sch)
+ if abs(actual_interval - nominal_interval) < \
+ timedelta(hours=1):
+ now = last_downloaded + nominal_interval
+ x.set('last_downloaded', now.isoformat())
+ break
+ self.write_scheduler_file()
+
+ def get_to_be_downloaded_recipes(self):
+ ans = []
+ with self.lock:
+ for recipe in self.iter_recipes():
+ if self.recipe_needs_to_be_downloaded(recipe):
+ ans.append(recipe.get('id'))
+ return ans
+
+ def write_scheduler_file(self):
+ from calibre.utils.lock import ExclusiveFile
+ with ExclusiveFile(self.conf_path) as f:
+ f.seek(0)
+ f.truncate()
+ f.write(etree.tostring(self.root, encoding='utf-8',
+ xml_declaration=True, pretty_print=True))
+
+ def serialize_schedule(self, typ, schedule):
+ s = E.schedule({'type':typ})
+ if typ == 'interval':
+ if schedule < 0.1:
+ schedule = 1/24.
+ text = '%f'%schedule
+ elif typ == 'day/time':
+ text = '%d:%d:%d'%schedule
+ s.text = text
+ return s
+
+ def un_serialize_schedule(self, recipe):
+ for x in recipe.iterdescendants():
+ if 'schedule' in x.tag:
+ sch, typ = x.text, x.get('type')
+ if typ == 'interval':
+ sch = float(sch)
+ elif typ == 'day/time':
+ sch = list(map(int, sch.split(':')))
+ return typ, sch, parser.parse(recipe.get('last_downloaded'))
+
+ def recipe_needs_to_be_downloaded(self, recipe):
+ try:
+ typ, sch, ld = self.un_serialize_schedule(recipe)
+ except:
+ return False
+ if typ == 'interval':
+ return datetime.utcnow() - ld > timedelta(sch)
+ elif typ == 'day/time':
+ day, hour, minute = sch
+ now = datetime.now()
+ is_today = day < 0 or day > 6 or \
+ day == calendar.weekday(now.year, now.month, now.day)
+ return is_today and datetime.utcnow().date() != ld.date() and \
+ now.hour >= hour and now.minute >= minute
+ return False
+
+ def set_account_info(self, urn, un, pw):
+ with self.lock:
+ for x in list(self.iter_accounts()):
+ if x.get('id', False) == urn:
+ self.root.remove(x)
+ break
+ ac = E.account_info({'id':urn, 'username':un, 'password':pw})
+ self.root.append(ac)
+ self.write_scheduler_file()
+
+ def get_account_info(self, urn):
+ with self.lock:
+ for x in self.iter_accounts():
+ if x.get('id', False) == urn:
+ return x.get('username', ''), x.get('password', '')
+
+ def get_customize_info(self, urn):
+ add_title_tag = True
+ custom_tags = []
+ with self.lock:
+ for x in self.iter_customization():
+ if x.get('id', False) == urn:
+ add_title_tag = x.get('add_title_tag', 'yes') == 'yes'
+ custom_tags = [i.strip() for i in x.get('custom_tags',
+ '').split(',')]
+ break
+ return add_title_tag, custom_tags
+
+ def get_schedule_info(self, urn):
+ with self.lock:
+ for x in self.iter_recipes():
+ if x.get('id', False) == urn:
+ ans = list(self.un_serialize_schedule(x))
+ return ans
+
+ def migrate_old_conf(self, old_conf_path):
+ from calibre.utils.config import DynamicConfig
+ c = DynamicConfig('scheduler')
+ for r in c.get('scheduled_recipes', []):
+ try:
+ self.add_old_recipe(r)
+ except:
+ continue
+ for k in c.keys():
+ if k.startswith('recipe_account_info'):
+ try:
+ urn = k.replace('recipe_account_info_', '')
+ if urn.startswith('recipe_'):
+ urn = 'builtin:'+urn[7:]
+ else:
+ urn = 'custom:%d'%int(urn)
+ try:
+ username, password = c[k]
+ except:
+ username = password = ''
+ self.set_account_info(urn, unicode(username),
+ unicode(password))
+ except:
+ continue
+ del c
+ self.write_scheduler_file()
+ try:
+ os.remove(old_conf_path)
+ except:
+ pass
+
+ def add_old_recipe(self, r):
+ urn = None
+ if r['builtin'] and r['id'].startswith('recipe_'):
+ urn = 'builtin:'+r['id'][7:]
+ elif not r['builtin']:
+ try:
+ urn = 'custom:%d'%int(r['id'])
+ except:
+ return
+ schedule = r['schedule']
+ typ = 'interval'
+ if schedule > 1e5:
+ typ = 'day/time'
+ raw = '%d'%int(schedule)
+ day = int(raw[0]) - 1
+ hour = int(raw[2:4]) - 1
+ minute = int(raw[-2:]) - 1
+ if day >= 7:
+ day = -1
+ schedule = [day, hour, minute]
+ recipe = {'id':urn, 'title':r['title']}
+ self.schedule_recipe(recipe, typ, schedule,
+ last_downloaded=r['last_downloaded'])
+
+
+
+
diff --git a/src/calibre/web/feeds/recipes/model.py b/src/calibre/web/feeds/recipes/model.py
new file mode 100644
index 0000000000..9efcd9e78e
--- /dev/null
+++ b/src/calibre/web/feeds/recipes/model.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python
+# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
+from __future__ import with_statement
+
+__license__ = 'GPL v3'
+__copyright__ = '2009, Kovid Goyal '
+__docformat__ = 'restructuredtext en'
+
+import os, copy
+
+from PyQt4.Qt import QAbstractItemModel, QVariant, Qt, QColor, QFont, QIcon, \
+ QModelIndex, SIGNAL
+
+from calibre.utils.search_query_parser import SearchQueryParser
+from calibre.gui2 import NONE
+from calibre.utils.localization import get_language
+from calibre.web.feeds.recipes.collection import \
+ get_builtin_recipe_collection, get_custom_recipe_collection, \
+ SchedulerConfig
+from calibre.utils.pyparsing import ParseException
+
+class NewsTreeItem(object):
+
+ def __init__(self, builtin, custom, scheduler_config, parent=None):
+ self.builtin, self.custom = builtin, custom
+ self.scheduler_config = scheduler_config
+ self.parent = parent
+ if self.parent is not None:
+ self.parent.append(self)
+ self.children = []
+
+ def row(self):
+ if self.parent is not None:
+ return self.parent.children.index(self)
+ return 0
+
+ def append(self, child):
+ child.parent = self
+ self.children.append(child)
+
+ def data(self, role):
+ return NONE
+
+ def flags(self):
+ return Qt.ItemIsEnabled|Qt.ItemIsSelectable
+
+ def sort(self):
+ self.children.sort()
+ for child in self.children:
+ child.sort()
+
+ def prune(self):
+ for child in list(self.children):
+ if len(child.children) == 0:
+ self.children.remove(child)
+ child.parent = None
+
+class NewsCategory(NewsTreeItem):
+
+ def __init__(self, category, builtin, custom, scheduler_config, parent):
+ NewsTreeItem.__init__(self, builtin, custom, scheduler_config, parent)
+ self.category = category
+ self.cdata = get_language(self.category)
+ self.bold_font = QFont()
+ self.bold_font.setBold(True)
+ self.bold_font = QVariant(self.bold_font)
+
+ def data(self, role):
+ if role == Qt.DisplayRole:
+ return QVariant(self.cdata + ' [%d]'%len(self.children))
+ elif role == Qt.FontRole:
+ return self.bold_font
+ elif role == Qt.ForegroundRole and self.category == _('Scheduled'):
+ return QVariant(QColor(0, 255, 0))
+ return NONE
+
+ def flags(self):
+ return Qt.ItemIsEnabled
+
+ def __cmp__(self, other):
+ def decorate(x):
+ if x == _('Scheduled'):
+ x = '0' + x
+ elif x == _('Custom'):
+ x = '1' + x
+ else:
+ x = '2' + x
+ return x
+
+ return cmp(decorate(self.cdata), decorate(getattr(other, 'cdata', '')))
+
+
+class NewsItem(NewsTreeItem):
+
+ def __init__(self, urn, title, default_icon, custom_icon,
+ builtin, custom, scheduler_config, parent):
+ NewsTreeItem.__init__(self, builtin, custom, scheduler_config, parent)
+ self.urn, self.title = urn, title
+ if 'custom:' in self.urn:
+ self.icon = custom_icon
+ else:
+ icon = I('news/%s.png'%self.urn[8:])
+ if os.path.exists(icon):
+ self.icon = QVariant(QIcon(icon))
+ else:
+ self.icon = default_icon
+
+ def data(self, role):
+ if role == Qt.DisplayRole:
+ return QVariant(self.title)
+ if role == Qt.DecorationRole:
+ return self.icon
+ return NONE
+
+ def __cmp__(self, other):
+ return cmp(self.title, getattr(other, 'title', ''))
+
+class RecipeModel(QAbstractItemModel, SearchQueryParser):
+
+ LOCATIONS = ['all']
+
+ def __init__(self, db, *args):
+ QAbstractItemModel.__init__(self, *args)
+ SearchQueryParser.__init__(self)
+ self.db = db
+ self.default_icon = QVariant(QIcon(I('news.svg')))
+ self.custom_icon = QVariant(QIcon(I('user_profile.svg')))
+ self.builtin_recipe_collection = get_builtin_recipe_collection()
+ self.scheduler_config = SchedulerConfig()
+ self.do_refresh()
+
+ def get_recipe(self, urn):
+ coll = self.custom_recipe_collection if urn.startswith('custom:') \
+ else self.builtin_recipe_collection
+ for recipe in coll:
+ if recipe.get('id', False) == urn:
+ if coll is self.builtin_recipe_collection:
+ return P('recipes/%s.recipe'%urn[8:], data=True)
+ return self.db.get_feed(int(urn[len('custom:'):]))
+
+ def update_custom_recipe(self, urn, title, script):
+ self.db.update_feed(int(urn[len('custom:'):]), script, title)
+ self.custom_recipe_collection = get_custom_recipe_collection(self.db)
+
+ def add_custom_recipe(self, title, script):
+ self.db.add_feed(title, script)
+ self.custom_recipe_collection = get_custom_recipe_collection(self.db)
+
+ def remove_custom_recipes(self, urns):
+ ids = [int(x[len('custom:'):]) for x in urns]
+ self.db.remove_feeds(ids)
+ self.custom_recipe_collection = get_custom_recipe_collection(self.db)
+
+ def do_refresh(self, restrict_to_urns=set([])):
+ self.custom_recipe_collection = get_custom_recipe_collection(self.db)
+
+ def factory(cls, parent, *args):
+ args = list(args)
+ if cls is NewsItem:
+ args.extend([self.default_icon, self.custom_icon])
+ args += [self.builtin_recipe_collection,
+ self.custom_recipe_collection, self.scheduler_config,
+ parent]
+ return cls(*args)
+
+ def ok(urn):
+ return not restrict_to_urns or urn in restrict_to_urns
+
+ new_root = factory(NewsTreeItem, None)
+ scheduled = factory(NewsCategory, new_root, _('Scheduled'))
+ custom = factory(NewsCategory, new_root, _('Custom'))
+ lang_map = {}
+ self.all_urns = set([])
+ self.showing_count = 0
+ for x in self.scheduler_config.iter_recipes():
+ urn = x.get('id')
+ if ok(urn):
+ factory(NewsItem, scheduled, urn, x.get('title'))
+ for x in self.custom_recipe_collection:
+ urn = x.get('id')
+ self.all_urns.add(urn)
+ if ok(urn):
+ factory(NewsItem, custom, urn, x.get('title'))
+ self.showing_count += 1
+ for x in self.builtin_recipe_collection:
+ urn = x.get('id')
+ self.all_urns.add(urn)
+ if ok(urn):
+ lang = x.get('language', 'und')
+ if lang not in lang_map:
+ lang_map[lang] = factory(NewsCategory, new_root, lang)
+ factory(NewsItem, lang_map[lang], urn, x.get('title'))
+ self.showing_count += 1
+ new_root.prune()
+ new_root.sort()
+ self.root = new_root
+ self.reset()
+
+ def recipe_from_urn(self, urn):
+ coll = self.custom_recipe_collection if 'custom:' in urn else \
+ self.builtin_recipe_collection
+ for x in coll:
+ if x.get('id', None) == urn:
+ return copy.deepcopy(x)
+
+ def schedule_info_from_urn(self, urn):
+ return self.scheduler_config.get_schedule_info(urn)
+
+ def account_info_from_urn(self, urn):
+ return self.scheduler_config.get_account_info(urn)
+
+ def universal_set(self):
+ return self.all_urns
+
+ def get_customize_info(self, urn):
+ return self.scheduler_config.get_customize_info(urn)
+
+ def get_matches(self, location, query):
+ query = query.strip().lower()
+ if not query:
+ return self.universal_set()
+ results = set([])
+ for urn in self.universal_set():
+ recipe = self.recipe_from_urn(urn)
+ if query in recipe.get('title', '').lower() or \
+ query in recipe.get('description', '').lower():
+ results.add(urn)
+ return results
+
+ def search(self, query, refinement):
+ try:
+ results = self.parse(unicode(query))
+ except ParseException:
+ results = []
+ self.do_refresh(restrict_to_urns=results)
+ self.emit(SIGNAL('searched(PyQt_PyObject)'), True)
+
+ def columnCount(self, parent):
+ return 1
+
+ def data(self, index, role):
+ if not index.isValid():
+ return NONE
+ item = index.internalPointer()
+ return item.data(role)
+
+ def headerData(self, *args):
+ return NONE
+
+ def flags(self, index):
+ if not index.isValid():
+ return Qt.ItemIsEnabled|Qt.ItemIsSelectable
+ item = index.internalPointer()
+ return item.flags()
+
+ def resort(self):
+ self.do_refresh()
+
+ def index(self, row, column, parent):
+ if not self.hasIndex(row, column, parent):
+ return QModelIndex()
+
+ if not parent.isValid():
+ parent_item = self.root
+ else:
+ parent_item = parent.internalPointer()
+
+ try:
+ child_item = parent_item.children[row]
+ except IndexError:
+ return QModelIndex()
+
+ ans = self.createIndex(row, column, child_item)
+ return ans
+
+ def parent(self, index):
+ if not index.isValid():
+ return QModelIndex()
+
+ child_item = index.internalPointer()
+ parent_item = child_item.parent
+
+ if parent_item is self.root or parent_item is None:
+ return QModelIndex()
+
+ ans = self.createIndex(parent_item.row(), 0, parent_item)
+ return ans
+
+ def rowCount(self, parent):
+ if parent.column() > 0:
+ return 0
+
+ if not parent.isValid():
+ parent_item = self.root
+ else:
+ parent_item = parent.internalPointer()
+
+ return len(parent_item.children)
+
+ def update_recipe_schedule(self, urn, schedule_type, schedule,
+ add_title_tag=True, custom_tags=[]):
+ recipe = self.recipe_from_urn(urn)
+ self.scheduler_config.schedule_recipe(recipe, schedule_type, schedule,
+ add_title_tag=add_title_tag, custom_tags=custom_tags)
+
+ def update_last_downloaded(self, urn):
+ self.scheduler_config.update_last_downloaded(urn)
+
+ def set_account_info(self, urn, un, pw):
+ self.scheduler_config.set_account_info(urn, un, pw)
+
+ def get_account_info(self, urn):
+ return self.scheduler_config.get_account_info(urn)
+
+ def get_schedule_info(self, urn):
+ return self.scheduler_config.get_schedule_info(urn)
+
+ def un_schedule_recipe(self, urn):
+ self.scheduler_config.un_schedule_recipe(urn)
+
+ def schedule_recipe(self, urn, sched_type, schedule):
+ self.scheduler_config.schedule_recipe(self.recipe_from_urn(urn),
+ sched_type, schedule)
+
+ def customize_recipe(self, urn, add_title_tag, custom_tags):
+ self.scheduler_config.customize_recipe(urn, add_title_tag,
+ custom_tags)
+
+ def get_to_be_downloaded_recipes(self):
+ return self.scheduler_config.get_to_be_downloaded_recipes()
+
+ def scheduled_urns(self):
+ ans = []
+ with self.scheduler_config.lock:
+ for recipe in self.scheduler_config.iter_recipes():
+ ans.append(recipe.get('id'))
+ return ans
+
+
+