import pytz
import rarfile
from rarfile import RarFile, is_rarfile
from requests import Session
from zipfile import ZipFile, is_zipfile
from . import ParserBeautifulSoup, Provider
from .. import __short_version__
from ..cache import SHOW_EXPIRATION_TIME, region
from ..exceptions import AuthenticationError, ConfigurationError, ProviderError, ServiceUnavailable
from ..subtitle import SUBTITLE_EXTENSIONS, Subtitle, fix_line_ending, guess_matches, sanitize
from ..video import Episode, Movie
logger = logging.getLogger(__name__)
language_converters.register(
'legendastv = subliminal.converters.legendastv:LegendasTVConverter')
# Configure :mod:`rarfile` to use the same path separator as :mod:`zipfile`
rarfile.PATH_SEP = '/'
#: Conversion map for types
type_map = {'M': 'movie', 'S': 'episode', 'C': 'episode'}
#: BR title season parsing regex
season_re = re.compile(
r' - (?P<season>\d+)(\xaa|a|st|nd|rd|th) (temporada|season)',
re.IGNORECASE)
#: Downloads parsing regex
downloads_re = re.compile(r'(?P<downloads>\d+) downloads')
# -*- coding: utf-8 -*-
import logging
from babelfish import Language, language_converters
from requests import Session
from . import Provider
from .. import __short_version__
from ..subtitle import Subtitle, fix_line_ending
logger = logging.getLogger(__name__)
language_converters.register(
'thesubdb = subliminal.converters.thesubdb:TheSubDBConverter')
class TheSubDBSubtitle(Subtitle):
"""TheSubDB Subtitle."""
provider_name = 'thesubdb'
def __init__(self, language, hash):
super(TheSubDBSubtitle, self).__init__(language)
self.hash = hash
@property
def id(self):
return self.hash + '-' + str(self.language)
def get_matches(self, video):
matches = set()
def fix_inconsistent_naming(title):
"""Fix titles with inconsistent naming using dictionary and sanitize them.
:param str title: original title.
:return: new title.
:rtype: str
"""
return _fix_inconsistent_naming(title, {"Stargate Origins": "Stargate: Origins",
"Marvel's Agents of S.H.I.E.L.D.": "Marvels+Agents+of+S.H.I.E.L.D",
"Mayans M.C.": "Mayans MC"}, True)
logger = logging.getLogger(__name__)
language_converters.register('hosszupuska = subliminal_patch.converters.hosszupuska:HosszupuskaConverter')
class HosszupuskaSubtitle(Subtitle):
"""Hosszupuska Subtitle."""
provider_name = 'hosszupuska'
def __str__(self):
subtit = "Subtitle id: " + str(self.subtitle_id) \
+ " Series: " + self.series \
+ " Season: " + str(self.season) \
+ " Episode: " + str(self.episode) \
+ " Releases: " + str(self.releases)
if self.year:
subtit = subtit + " Year: " + str(self.year)
if six.PY3:
# -*- coding: utf-8 -*-
import logging
from babelfish import Language, language_converters
from requests import Session
from . import Provider, get_version
from .. import __version__
from ..subtitle import Subtitle, fix_line_ending
logger = logging.getLogger(__name__)
language_converters.register('thesubdb = subliminal.converters.thesubdb:TheSubDBConverter')
class TheSubDBSubtitle(Subtitle):
provider_name = 'thesubdb'
def __init__(self, language, hash):
super(TheSubDBSubtitle, self).__init__(language)
self.hash = hash
@property
def id(self):
return self.hash + '-' + str(self.language)
def get_matches(self, video):
matches = set()
# hash
if 'thesubdb' in video.hashes and video.hashes['thesubdb'] == self.hash:
import re
import zipfile
from babelfish import Language, language_converters
from guessit import guessit
from requests import Session
from subliminal import Provider
from subliminal.exceptions import ProviderError
from subliminal.providers import ParserBeautifulSoup
from subliminal.subtitle import Subtitle, fix_line_ending, guess_matches
from subliminal.utils import sanitize
from subliminal.video import Episode, Movie
logger = logging.getLogger(__name__)
language_converters.register(b'subscene = sickrage.subtitles.converters.subscene:SubsceneConverter')
class SubsceneSubtitle(Subtitle):
"""Subscene Subtitle."""
provider_name = 'subscene'
def __init__(self, language, hearing_impaired, series, season, episode, title, sub_id, releases):
super(SubsceneSubtitle, self).__init__(language, hearing_impaired)
self.series = series
self.season = season
self.episode = episode
self.title = title
self.sub_id = sub_id
self.downloaded = 0
self.releases = releases
from guessit import guessit
from rarfile import RarFile, is_rarfile
from requests import Session
from zipfile import ZipFile, is_zipfile
from . import ParserBeautifulSoup, Provider
from ..cache import region, EPISODE_EXPIRATION_TIME, SHOW_EXPIRATION_TIME
from ..exceptions import AuthenticationError, ConfigurationError
from ..subtitle import SUBTITLE_EXTENSIONS, Subtitle, fix_line_ending, guess_matches, sanitize
from ..video import Episode, Movie
TIMEOUT = 10
logger = logging.getLogger(__name__)
language_converters.register('legendastv = subliminal.converters.legendastv:LegendasTvConverter')
class LegendasTvSubtitle(Subtitle):
provider_name = 'legendastv'
def __init__(self, language, page_link, subtitle_id, name, binary_content, imdb_id=None, type=None, season=None,
year=None, no_downloads=None, rating=None, featured=False, multiple_episodes=False, timestamp=None):
super(LegendasTvSubtitle, self).__init__(language, page_link=page_link)
self.subtitle_id = subtitle_id
self.name = name
self.imdb_id = imdb_id
self.type = type
self.season = season
self.year = year
self.no_downloads = no_downloads
import re
from babelfish import language_converters
from guessit import guessit
from requests import Session
from subliminal import Movie, Episode, ProviderError, __short_version__
from subliminal.exceptions import AuthenticationError, ConfigurationError, DownloadLimitExceeded, ProviderError
from subliminal_patch.subtitle import Subtitle, guess_matches
from subliminal.subtitle import fix_line_ending
from subliminal_patch.providers import Provider
from subzero.language import Language
logger = logging.getLogger(__name__)
language_converters.register('assrt = subliminal_patch.converters.assrt:AssrtConverter')
server_url = 'https://api.assrt.net/v1'
supported_languages = language_converters['assrt'].to_assrt.keys()
class AssrtSubtitle(Subtitle):
"""Assrt Sbutitle."""
provider_name = 'assrt'
guessit_options = {
'allowed_languages': [ l[0] for l in supported_languages ],
'allowed_countries': [ l[1] for l in supported_languages if len(l) > 1 ],
'enforce_list': True
}
def __init__(self, language, subtitle_id, video_name, session, token):
from dogpile.cache.api import NO_VALUE
from subliminal import Episode, ProviderError
from subliminal.exceptions import ConfigurationError, ServiceUnavailable
from subliminal.utils import sanitize_release_group
from subliminal.cache import region
from subliminal_patch.http import RetryingCFSession
from subliminal_patch.providers import Provider
from subliminal_patch.providers.mixins import ProviderSubtitleArchiveMixin
from subliminal_patch.subtitle import Subtitle, guess_matches
from subliminal_patch.converters.subscene import language_ids, supported_languages
from subscene_api.subscene import search, Subtitle as APISubtitle, SITE_DOMAIN
from subzero.language import Language
p = inflect.engine()
language_converters.register('subscene = subliminal_patch.converters.subscene:SubsceneConverter')
logger = logging.getLogger(__name__)
class SubsceneSubtitle(Subtitle):
provider_name = 'subscene'
hearing_impaired_verifiable = True
is_pack = False
page_link = None
season = None
episode = None
releases = None
def __init__(self, language, release_info, hearing_impaired=False, page_link=None, encoding=None, mods=None,
asked_for_release_group=None, asked_for_episode=None):
super(SubsceneSubtitle, self).__init__(language, hearing_impaired=hearing_impaired, page_link=page_link,
if (alpha3, country) in self.to_tusubtitulo:
return self.to_tusubtitulo[(alpha3, country)]
if (alpha3, ) in self.to_tusubtitulo:
return self.to_tusubtitulo[(alpha3, )]
return self.name_converter.convert(alpha3, country, script)
def reverse(self, tusubtitulo):
if tusubtitulo in self.from_tusubtitulo:
return self.from_tusubtitulo[tusubtitulo]
return self.name_converter.reverse(tusubtitulo)
language_converters.register(
'tusubtitulo = sickchill.providers.subtitle.tusubtitulo:TuSubtituloConverter'
)
#: Release parsing regex
release_pattern = re.compile('Versi.+n (.+)')
class TuSubtituloSubtitle(Subtitle):
"""TuSubtitulo Subtitle."""
provider_name = 'tusubtitulo'
def __init__(self, language, hearing_impaired, page_link, series, season,
episode, title, year, version, download_link):
super(TuSubtituloSubtitle, self).__init__(language, hearing_impaired,
page_link)
self.page_link = page_link
from subliminal.providers import ParserBeautifulSoup
from subliminal_patch.providers import Provider
from subliminal.subtitle import (
SUBTITLE_EXTENSIONS,
fix_line_ending
)
from subliminal_patch.subtitle import (
Subtitle,
guess_matches
)
from .utils import FIRST_THOUSAND_OR_SO_USER_AGENTS as AGENT_LIST
from subliminal.video import Episode, Movie
logger = logging.getLogger(__name__)
language_converters.register('zimuku = subliminal_patch.converters.zimuku:zimukuConverter')
supported_languages = list(language_converters['zimuku'].to_zimuku.keys())
class ZimukuSubtitle(Subtitle):
"""Zimuku Subtitle."""
provider_name = "zimuku"
def __init__(self, language, page_link, version, session, year):
super(ZimukuSubtitle, self).__init__(language, page_link=page_link)
self.version = version
self.release_info = version
self.hearing_impaired = False
self.encoding = "utf-8"
self.session = session
from babelfish import Language, language_converters
from guessit import guessit
from requests import Session
from . import ParserBeautifulSoup, Provider
from .. import __short_version__
from ..cache import SHOW_EXPIRATION_TIME, region
from ..exceptions import AuthenticationError, ConfigurationError, DownloadLimitExceeded
from ..score import get_equivalent_release_groups
from ..subtitle import Subtitle, fix_line_ending, guess_matches
from ..utils import sanitize, sanitize_release_group
from ..video import Episode
logger = logging.getLogger(__name__)
language_converters.register(
'subtitulamos = subliminal.converters.subtitulamos:SubtitulamosConverter')
class SubtitulamosSubtitle(Subtitle):
"""Subtitulamos.tv Subtitle."""
provider_name = 'subtitulamos'
def __init__(self, language, series, season, episode, title, version,
download_link):
super(SubtitulamosSubtitle, self).__init__(language)
self.series = series
self.season = season
self.episode = episode
self.title = title
self.version = version
self.download_link = download_link
from requests import Session
from subliminal.cache import EPISODE_EXPIRATION_TIME, region
from subliminal.exceptions import ProviderError
from subliminal.matches import guess_matches
from subliminal.providers import ParserBeautifulSoup, Provider
from subliminal.score import get_equivalent_release_groups
from subliminal.subtitle import Subtitle, fix_line_ending
from subliminal.utils import sanitize, sanitize_release_group
from subliminal.video import Episode
logger = logging.getLogger(__name__)
language_converters.register(
'subtitulamos = medusa.subtitle_providers.converters.subtitulamos:SubtitulamosConverter'
)
class SubtitulamosSubtitle(Subtitle):
"""Subtitulamos Subtitle."""
provider_name = 'subtitulamos'
def __init__(self, language, hearing_impaired, page_link, series, season,
episode, title, year, version, download_link):
super(SubtitulamosSubtitle, self).__init__(language, hearing_impaired,
page_link)
self.page_link = page_link
self.series = series
self.season = season
from babelfish import language_converters
from guessit import guessit
from subliminal import Episode, ProviderError
from subliminal.utils import sanitize_release_group
from subliminal_patch.http import RetryingCFSession
from subliminal_patch.providers import Provider
from subliminal_patch.providers.mixins import ProviderSubtitleArchiveMixin
from subliminal_patch.subtitle import Subtitle, guess_matches
from subliminal_patch.converters.subscene import language_ids, supported_languages
from subscene_api.subscene import search, Subtitle as APISubtitle
from subzero.language import Language
p = inflect.engine()
language_converters.register('subscene = subliminal_patch.converters.subscene:SubsceneConverter')
logger = logging.getLogger(__name__)
class SubsceneSubtitle(Subtitle):
provider_name = 'subscene'
hearing_impaired_verifiable = True
is_pack = False
page_link = None
season = None
episode = None
releases = None
def __init__(self, language, release_info, hearing_impaired=False, page_link=None, encoding=None, mods=None,
asked_for_release_group=None, asked_for_episode=None):
super(SubsceneSubtitle, self).__init__(language, hearing_impaired=hearing_impaired, page_link=page_link,
import re
from babelfish import Language, language_converters
from guessit import guessit
from requests import Session
from . import ParserBeautifulSoup, Provider, get_version
from .. import __version__
from ..cache import SHOW_EXPIRATION_TIME, region
from ..exceptions import AuthenticationError, ConfigurationError, DownloadLimitExceeded, TooManyRequests
from ..subtitle import Subtitle, fix_line_ending, guess_matches, sanitize_string, sanitized_string_equal
from ..video import Episode
logger = logging.getLogger(__name__)
language_converters.register('addic7ed = subliminal.converters.addic7ed:Addic7edConverter')
series_year_re = re.compile('^(?P<series>[ \w\'.:-]+)(?: \((?P<year>\d{4})\))?$')
class Addic7edSubtitle(Subtitle):
provider_name = 'addic7ed'
def __init__(self, language, hearing_impaired, page_link, series, season, episode, title, year, version,
download_link):
super(Addic7edSubtitle, self).__init__(language, hearing_impaired, page_link)
self.series = series
self.season = season
self.episode = episode
self.title = title
self.year = year
import re
from babelfish import language_converters
from guessit import guessit
from requests import Session
from subliminal import Movie, Episode, ProviderError, __short_version__
from subliminal.exceptions import AuthenticationError, ConfigurationError, DownloadLimitExceeded, ProviderError
from subliminal_patch.subtitle import Subtitle, guess_matches
from subliminal.subtitle import fix_line_ending
from subliminal_patch.providers import Provider
from subzero.language import Language
logger = logging.getLogger(__name__)
language_converters.register(
'assrt = subliminal_patch.converters.assrt:AssrtConverter')
server_url = 'https://api.assrt.net/v1'
supported_languages = list(language_converters['assrt'].to_assrt.keys())
def language_contains(subset, superset):
if subset.alpha3 != superset.alpha3:
return False
if superset.country != None and subset.country != superset.country:
return False
if superset.script != None and subset.script != superset.script:
return False
return True
from subliminal_patch.providers.mixins import ProviderSubtitleArchiveMixin
from subliminal.providers import ParserBeautifulSoup
from subliminal_patch.exceptions import ProviderError
from subliminal.score import get_equivalent_release_groups
from subliminal_patch.subtitle import Subtitle, guess_matches
from subliminal.utils import sanitize, sanitize_release_group
from subliminal.video import Episode, Movie
from zipfile import ZipFile, is_zipfile
from rarfile import RarFile, is_rarfile
from subliminal_patch.utils import sanitize, fix_inconsistent_naming as _fix_inconsistent_naming
from guessit import guessit
logger = logging.getLogger(__name__)
language_converters.register('supersubtitles = subliminal_patch.converters.supersubtitles:SuperSubtitlesConverter')
class SuperSubtitlesSubtitle(Subtitle):
"""SuperSubtitles Subtitle."""
provider_name = 'supersubtitles'
def __str__(self):
subtit = "Subtitle id: " + str(self.subtitle_id) \
+ " Series: " + self.series \
+ " Season: " + str(self.season) \
+ " Episode: " + str(self.episode) \
+ " Version: " + str(self.version) \
+ " Releases: " + str(self.releases) \
+ " DownloadLink: " + str(self.page_link) \
+ " Matches: " + str(self.matches)
def fix_inconsistent_naming(title):
"""Fix titles with inconsistent naming using dictionary and sanitize them.
:param str title: original title.
:return: new title.
:rtype: str
"""
return _fix_inconsistent_naming(title, {"Stargate Origins": "Stargate: Origins",
"Marvel's Agents of S.H.I.E.L.D.": "Marvels+Agents+of+S.H.I.E.L.D",
"Mayans M.C.": "Mayans MC"}, True)
logger = logging.getLogger(__name__)
language_converters.register('hosszupuska = subliminal_patch.converters.hosszupuska:HosszupuskaConverter')
class HosszupuskaSubtitle(Subtitle):
"""Hosszupuska Subtitle."""
provider_name = 'hosszupuska'
def __str__(self):
subtit = "Subtitle id: " + str(self.subtitle_id) \
+ " Series: " + self.series \
+ " Season: " + str(self.season) \
+ " Episode: " + str(self.episode) \
+ " Releases: " + str(self.releases)
if self.year:
subtit = subtit + " Year: " + str(self.year)
if six.PY3:
from babelfish import Language, language_converters
from guessit import guessit
from requests import Session
from . import ParserBeautifulSoup, Provider
from .. import __short_version__
from ..cache import SHOW_EXPIRATION_TIME, region
from ..exceptions import AuthenticationError, ConfigurationError, DownloadLimitExceeded
from ..score import get_equivalent_release_groups
from ..subtitle import Subtitle, fix_line_ending, guess_matches
from ..utils import sanitize, sanitize_release_group
from ..video import Episode
logger = logging.getLogger(__name__)
language_converters.register(
'addic7ed = subliminal.converters.addic7ed:Addic7edConverter')
# Series cell matching regex
show_cells_re = re.compile(b'<td class="version">.*?</td>', re.DOTALL)
#: Series header parsing regex
series_year_re = re.compile(
r'^(?P<series>[ \w\'.:(),*&!?-]+?)(?: \((?P<year>\d{4})\))?$')
class Addic7edSubtitle(Subtitle):
"""Addic7ed Subtitle."""
provider_name = 'addic7ed'
def __init__(self, language, hearing_impaired, page_link, series, season,
episode, title, year, version, download_link):
def convert(self, alpha3, country=None, script=None):
if (alpha3, country) in self.to_subtitulamos:
return self.to_subtitulamos[(alpha3, country)]
if (alpha3,) in self.to_subtitulamos:
return self.to_subtitulamos[(alpha3,)]
return self.name_converter.convert(alpha3, country, script)
def reverse(self, subtitulamos):
if subtitulamos in self.from_subtitulamos:
return self.from_subtitulamos[subtitulamos]
return self.name_converter.reverse(subtitulamos)
language_converters.register('subtitulamos = sickchill.providers.subtitle.subtitulamos:SubtitulamosConverter')
class SubtitulamosSubtitle(Subtitle):
"""Subtitulamos Subtitle."""
provider_name = 'subtitulamos'
def __init__(self, language, hearing_impaired, page_link, series, season, episode, title, year, version,
download_link):
super().__init__(language, hearing_impaired, page_link)
self.page_link = page_link
self.series = series
self.season = season
self.episode = episode
self.title = title
self.year = year
"""Fix titles with inconsistent naming using dictionary and sanitize them.
:param str title: original title.
:return: new title.
:rtype: str
"""
return _fix_inconsistent_naming(title, {"DC's Legends of Tomorrow": "Legends of Tomorrow",
"Marvel's Jessica Jones": "Jessica Jones"})
logger = logging.getLogger(__name__)
# Configure :mod:`rarfile` to use the same path separator as :mod:`zipfile`
rarfile.PATH_SEP = '/'
language_converters.register('titlovi = subliminal_patch.converters.titlovi:TitloviConverter')
class TitloviSubtitle(Subtitle):
provider_name = 'titlovi'
def __init__(self, language, page_link, download_link, sid, releases, title, alt_title=None, season=None,
episode=None, year=None, fps=None, asked_for_release_group=None, asked_for_episode=None):
super(TitloviSubtitle, self).__init__(language, page_link=page_link)
self.sid = sid
self.releases = self.release_info = releases
self.title = title
self.alt_title = alt_title
self.season = season
self.episode = episode
self.year = year
# -*- coding: utf-8 -*-
import json
import logging
import os
from babelfish import Language, language_converters
from requests import Session
from . import Provider
from .. import __short_version__
from ..subtitle import Subtitle, fix_line_ending
logger = logging.getLogger(__name__)
language_converters.register('shooter = subliminal.converters.shooter:ShooterConverter')
class ShooterSubtitle(Subtitle):
"""Shooter Subtitle."""
provider_name = 'shooter'
def __init__(self, language, hash, download_link):
super(ShooterSubtitle, self).__init__(language)
self.hash = hash
self.download_link = download_link
def id(self):
return self.download_link
def get_matches(self, video):
matches = set()
from zipfile import ZipFile
from babelfish import Language, language_converters
from guessit import guessit
from requests import Session
from . import ParserBeautifulSoup, Provider
from .. import __short_version__
from ..cache import EPISODE_EXPIRATION_TIME, SHOW_EXPIRATION_TIME, region
from ..exceptions import ProviderError
from ..subtitle import Subtitle, fix_line_ending, guess_matches
from ..video import Episode, sanitize
logger = logging.getLogger(__name__)
language_converters.register('tvsubtitles = subliminal.converters.tvsubtitles:TVsubtitlesConverter')
link_re = re.compile('^(?P<series>.+?)(?: \(?\d{4}\)?| \((?:US|UK)\))? \((?P<first_year>\d{4})-\d{4}\)$')
episode_id_re = re.compile('^episode-\d+\.html$')
class TVsubtitlesSubtitle(Subtitle):
provider_name = 'tvsubtitles'
def __init__(self, language, page_link, subtitle_id, series, season, episode, year, rip, release):
super(TVsubtitlesSubtitle, self).__init__(language, page_link=page_link)
self.subtitle_id = subtitle_id
self.series = series
self.season = season
self.episode = episode
self.year = year
"""Fix titles with inconsistent naming using dictionary and sanitize them.
:param str title: original title.
:return: new title.
:rtype: str
"""
return _fix_inconsistent_naming(title, {"DC's Legends of Tomorrow": "Legends of Tomorrow",
"Marvel's Jessica Jones": "Jessica Jones"})
logger = logging.getLogger(__name__)
# Configure :mod:`rarfile` to use the same path separator as :mod:`zipfile`
rarfile.PATH_SEP = '/'
language_converters.register('titlovi = subliminal_patch.converters.titlovi:TitloviConverter')
class TitloviSubtitle(Subtitle):
provider_name = 'titlovi'
def __init__(self, language, page_link, download_link, sid, releases, title, alt_title=None, season=None,
episode=None, year=None, fps=None, asked_for_release_group=None, asked_for_episode=None):
super(TitloviSubtitle, self).__init__(language, page_link=page_link)
self.sid = sid
self.releases = self.release_info = releases
self.title = title
self.alt_title = alt_title
self.season = season
self.episode = episode
self.year = year
