Exemple #1
0
 def __init__(self, max_download_size, download_path, lang, initial_state):
     self.db_manager = Database.get_instance()
     self.scheduler = CronJobManager.get_instance()
     self.logger = logging.getLogger(__name__)
     self.download_path = utils.get_abs_path(download_path)
     self.max_download_size = max_download_size
     self.lang = lang
     self.initial_state = initial_state
     self.PROCESS_PASSWORD = range(
         initial_state, initial_state + BookDownloadHandler.num_states
     )
     self.entry_points = [CallbackQueryHandler(
         self.callback, pass_user_data=True
     )]
     self.states = {
         self.PROCESS_PASSWORD: [RegexHandler(
             '.*', self.process_password, pass_user_data=True
         )]
     }
     self.fallbacks=[RegexHandler('3248BC7547CE97B2A197B2A06CF7283D',
         self.cancel)]
     ConversationHandler.__init__(
         self,
         entry_points=self.entry_points,
         states=self.states,
         fallbacks=self.fallbacks,
         per_chat=False
     )
    def __init__(self):

        if CronJobManager.__instance != None:
            raise Exception("This class is a singleton!")
        else:
            self.update_cron_start_time()
            self.db_manager = Database.get_instance()
            self.dmm_ripper = DMMRipper.get_instance(
                CronJobManager.webdriver_config)
            jobstores = {
                # 'alchemy': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite'),
                'default': MemoryJobStore()
            }
            executors = {
                'default': {
                    'type': 'threadpool',
                    'max_workers': 20
                },
                'processpool': ProcessPoolExecutor(max_workers=5)
            }
            job_defaults = {'coalesce': False, 'max_instances': 3}
            self.scheduler = BackgroundScheduler()
            self.scheduler.configure(jobstores=jobstores,
                                     executors=executors,
                                     job_defaults=job_defaults,
                                     timezone=CronJobManager.time_zone,
                                     daemon=False)
            self.scheduler.start()
            CronJobManager.__instance = self
 def __init__(self, lang, language_codes, initial_state):
     self.db_manager = Database.get_instance()
     self.scheduler = CronJobManager.get_instance()
     self.logger = logging.getLogger(__name__)
     self.lang = lang
     self.language_codes = language_codes
     self.initial_state = initial_state
     self.LANGUAGE, self.EMAIL, self.PASSWORD, self.STORE_PASS = range(
         initial_state, initial_state + StartWizard.num_states)
     self.entry_points = [CommandHandler('start', self.start)]
     self.states = {
         self.LANGUAGE: [RegexHandler('.*', self.language)],
         self.EMAIL: [RegexHandler('.*', self.email)],
         self.STORE_PASS: [RegexHandler('.*', self.save_credentials)],
         self.PASSWORD: [RegexHandler('.*', self.password)],
     }
     self.fallbacks = [
         CommandHandler('10aec35353f9c4096a71c38654c3d402', self.cancel)
     ]
     ConversationHandler.__init__(self,
                                  entry_points=self.entry_points,
                                  states=self.states,
                                  fallbacks=self.fallbacks)
    def download_book_pages_job(book_path, missing_images, start_toc_missing,
                                book):

        db_manager = Database.get_instance()
        db_session = db_manager.create_session()
        dmm_cookies = None
        CronJobManager.logger.info('Starting download job of book %s', book.id)
        db_manager.set_volume_now_downloading(db_session, book.id, True)
        num_missing_images = len(missing_images)
        CronJobManager.notify_subscribers_download_progress(
            book,
            book.pages - num_missing_images,
            start_toc_missing,
            start_toc_missing=start_toc_missing)

        dmm_cookies = CronJobManager.get_dmm_cookies_for_book_download(book)
        download_failed = False

        if dmm_cookies:
            toc_path = path.join(book_path, 'toc.txt')
            if start_toc_missing:
                try:
                    CronJobManager.__instance.dmm_ripper.download_book_toc( \
                        book, toc_path)
                    is_toc_missing = False
                    CronJobManager.notify_subscribers_download_progress(
                        book,
                        book.pages - num_missing_images,
                        is_toc_missing,
                        edit_message=True)
                except Exception as e:
                    CronJobManager.logger.exception(e)
                    CronJobManager.__instance.dmm_ripper.close_broser_reader()
                    is_toc_missing = True
            else:
                is_toc_missing = False
            for index, page_num in enumerate(missing_images):
                try:
                    CronJobManager.__instance.dmm_ripper.download_book_page( \
                        book, page_num, \
                        path.join(book_path, '{}'.format(page_num))
                    )
                except:
                    CronJobManager.__instance.dmm_ripper.close_broser_reader()
                    download_failed = True
                CronJobManager.notify_subscribers_download_progress(
                    book,
                    book.pages - num_missing_images + index + 1,
                    is_toc_missing,
                    start_toc_missing=start_toc_missing,
                    edit_message=True)
            CronJobManager.__instance.dmm_ripper.close_broser_reader()
            CronJobManager.logger.info('Download of book %s has finished',
                                       book.id)
            for subscriber in CronJobManager.book_job[book.id]['download']:
                user = subscriber['user']
                subscriber['bot'].send_message(
                    chat_id=user.id,
                    text=CronJobManager.lang[user.language_code] \
                        ['download_finished'].format(
                            FileFormat(user.file_format).name.upper()
                        )
                )
                CronJobManager.__instance.subscribe_to_book_conversion( \
                    book, book_path, subscriber['user'], subscriber['bot'], \
                    from_download=True
                )
        if not dmm_cookies or download_failed:
            CronJobManager.logger.info('Unable to start the download of ' \
                + 'book %s', book.id)
            for subscriber in CronJobManager.book_job[book.id]:
                user = subscriber['user']
                CronJobManager.logger.info('Sending download error message ' \
                    + 'to subscriber %s', user.id)
                subscriber['bot'].send_message(
                    chat_id = user.id,
                    text = CronJobManager.lang[user.language_code] \
                        ['download_error']
                )
        db_manager.set_volume_now_downloading(db_session, book.id, False)
        CronJobManager.logger.info('Removing the registration of download ' \
            + 'job for book %s', book.id)
        CronJobManager.book_job[book.id]['download'] = []
    def cache_user_library(user, session=None, password=None, fast=False):
        db_manager = Database.get_instance()
        db_session = db_manager.create_session()
        db_manager.set_user_now_caching(db_session, user.id, True)
        CronJobManager.logger.info('Caching %s user\'s library', user.id)

        try:
            if session == None:
                if user.save_credentials:
                    password = user.password
                session = CronJobManager.__instance.dmm_ripper.get_session(
                    user.email, password, fast)
                CronJobManager.logger.info('Obtaining a new DMM session for ' \
                    + 'user %s', user.id)
            books = CronJobManager.__instance.dmm_ripper.get_purchased_books(
                session)
            db_session.add(user)
            for book in books:
                if book['series']:
                    serie = db_manager.get_manga_serie(db_session, book['url'])
                    if not serie:
                        serie = MangaSeries(title=book['name'],
                                            url=book['url'],
                                            thumbnail_dmm=book['thumbnail'])
                        db_session.add(serie)
                        CronJobManager.logger.info(
                            'Adding a new serie to DB: ' + '%s', serie.title)
                        CronJobManager.thumbnail(db_session, serie, db_manager)
                    CronJobManager.logger.info('Processing volumes of ' \
                        + 'series %s', serie.title)
                    volumes = CronJobManager.__instance.dmm_ripper \
                    .get_book_volumes(
                        session, book
                    )
                    for volume in volumes:
                        db_volume = db_manager.get_manga_volume(
                            db_session, volume['url'])
                        if not db_volume:
                            volume_details = CronJobManager.__instance \
                            .dmm_ripper.get_book_details(
                                session, volume['details_url']
                            )
                            db_volume = Manga(
                                title=volume['name'],
                                url=volume['url'],
                                thumbnail_dmm=volume['thumbnail'],
                                description=volume_details['description'],
                                pages=volume_details['pages'],
                                serie=serie)
                            db_session.add(db_volume)
                            CronJobManager.logger.info('Adding a new volume ' \
                                + ' to DB: %s', db_volume.title)
                            CronJobManager.thumbnail(db_session,
                                                     db_volume,
                                                     db_manager,
                                                     parent=serie)
                        if not db_manager.user_owns_volume(
                                db_session, user.id, db_volume.url):
                            CronJobManager.logger.info('Adding volume to ' \
                                + 'user %s', user.id)
                            try:
                                user.book_collection.append(db_volume)
                                db_manager.commit(db_session)
                            except Exception as e:
                                CronJobManager.logger.exception('Error ' \
                                    + 'adding volume to user %s', user.id)
                                db_manager.rollback(db_session)
                else:
                    book = db_manager.get_manga_volume(db_session, book['url'])
                    if not book:
                        book_details = CronJobManager.__instance.dmm_ripper \
                        .get_book_details(
                            session, book['details_url']
                        )
                        book = Manga(title=book['name'],
                                     url=book['url'],
                                     thumbnail_dmm=book['thumbnail'],
                                     description=book_details['description'],
                                     pages=book_details['pages'],
                                     serie=serie)
                        db_session.add(book)
                        CronJobManager.logger.info('Adding a new non series ' \
                            + 'book to DB: %s', book.title)
                        CronJobManager.thumbnail(db_session, book, db_manager)
                    if not db_manager.user_owns_volume(db_session, user.id,
                                                       book.url):
                        CronJobManager.logger.info('Adding non series book ' \
                            + 'to user %s', user.id)
                        try:
                            user.book_collection.append(book)
                            db_manager.commit(session)
                        except:
                            CronJobManager.logger.exception('Error adding ' \
                                + 'non series book to user %s', user.id)
                            db_manager.rollback(session)

            db_manager.set_user_cache_expire_date(
                db_session, user.id, CronJobManager.get_cache_expire_date())
            db_manager.set_user_cache_built(db_session, user.id, True)
            db_manager.set_user_login_error(db_session, user.id, False)
        except Exception as e:
            CronJobManager.logger.info('Unable to login to the DMM account ' \
                + 'of user %s', user.id)
            db_manager.set_user_login_error(db_session, user.id, True)
            CronJobManager.remove_scheduled_user_cache(user.id)
            CronJobManager.logger.exception(e)
        finally:
            CronJobManager.logger.info('%s user\'s library caching ended',
                                       user.id)
            db_manager.set_user_now_caching(db_session, user.id, False)
            db_manager.remove_session()
Exemple #6
0
 def __init__(self, lang):
     self.lang = lang
     self.db_manager = Database.get_instance()
     InlineQueryHandler.__init__(self,
                                 self.inline_query,
                                 pass_chat_data=True)
Exemple #7
0
import logging
import signal
import sys
import utilities as utils

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO)
logging.Formatter.converter = utils.logging_tz
logger = logging.getLogger(__name__)

lang = {'en': english.en, 'ja': japanese.ja, 'common': common.common}
language_codes = {'en': ['english', '英語'], 'ja': ['japanese', '日本語']}

db_manager = Database.get_instance()
scheduler = CronJobManager.get_instance(
    languages=lang, max_upload_size=Config.MAX_UPLOAD_SIZE, \
    webdriver_config=Config.WEBDRIVER
)
scheduler.set_download_path(Config.DOWNLOAD_PATH)


def error_callback(bot, update, error):
    logger.exception(error)


def shutdown():
    scheduler.close_dmm_ripper()

    def __init__(self, lang, language_codes, initial_state):

        self.db_manager = Database.get_instance()
        self.scheduler = CronJobManager.get_instance()
        self.lang = lang
        self.language_codes = language_codes
        self.initial_state = initial_state
        self.CONFIG, self.PROCESS_LANGUAGE, self.PROCESS_ACCOUNT, \
        self.PROCESS_LIBRARY, self.PROCESS_EMAIL, self.PROCESS_PASSWORD, \
        self.PROCESS_CREDENTIALS, self.PROCESS_UPDATE_LIBRARY_PASSWORD, \
        self.PROCESS_FILE_FORMAT = range(
            initial_state, initial_state + ConfigWizard.num_states
        )
        self.entry_points = [
            CommandHandler('config', self.request_config_menu)
        ]
        self.states = {
            self.CONFIG: [RegexHandler(
                self.mc_ml_regex(['language','account', 'library', 'exit']),
                self.config_menu
            )],
            self.PROCESS_LANGUAGE: [RegexHandler(
                '.*',
                self.process_language
            )],
            self.PROCESS_ACCOUNT: [RegexHandler(
                self.mc_ml_regex(
                    [
                        'email',
                        'password',
                        'save_credentials',
                        'back'
                    ]
                ), self.account
            )],
            self.PROCESS_LIBRARY: [RegexHandler(
                self.mc_ml_regex(
                    [
                        'update_library',
                        'file_format',
                        'back'
                    ]
                ), self.process_library
            )],
            self.PROCESS_EMAIL: [RegexHandler(
                '.*', self.process_email
            )],
            self.PROCESS_PASSWORD: [RegexHandler(
                '.*', self.process_password
            )],
            self.PROCESS_CREDENTIALS: [RegexHandler(
                self.mc_ml_regex(['yes', 'no']),
                self.process_save_credentials
            )],
            self.PROCESS_UPDATE_LIBRARY_PASSWORD: [RegexHandler('.*',
                self.process_password_update_library
            )],
            self.PROCESS_FILE_FORMAT: [RegexHandler(
                '^(' + self.lang['common']['zip'] + '|' \
                + self.lang['common']['pdf'] + '|' \
                + self.lang['common']['epub'] + ')$',
                self.process_file_format
            )]
        }
        self.fallbacks = [
            RegexHandler('3248BC7547CE97B2A197B2A06CF7283D', self.cancel)
        ]

        ConversationHandler.__init__(self,
                                     entry_points=self.entry_points,
                                     states=self.states,
                                     fallbacks=self.fallbacks)