diff --git a/addon.xml b/addon.xml
index d67e56d..39c9855 100644
--- a/addon.xml
+++ b/addon.xml
@@ -1,18 +1,25 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <addon id="service.subtitles.bsplayer"
        name="BSPlayer"
-       version="0.2.1"
+       version="0.3.0"
        provider-name="realgam3">
-  <requires>
-    <import addon="xbmc.python" version="2.1.0"/>
-  </requires>
-  <extension point="xbmc.subtitle.module"
-             library="service.py" />
-  <extension point="xbmc.addon.metadata">
-    <summary lang="en">Kodi / XBMC BSPlayer Subtitles allows for downloading subtitles from the bsplayer subtitles community.</summary>
-    <description lang="en">Search and download various subtitles from the bsplayer subtitles community.</description>
-    <source>https://github.com/realgam3/service.subtitles.bsplayer</source>
-    <email>realgam3@gmail.com</email>
-    <license>GNU GENERAL PUBLIC LICENSE. Version 2, June 1991</license>
-  </extension>
+    <requires>
+        <import addon="xbmc.python" version="3.0.0"/>
+    </requires>
+    <extension point="xbmc.subtitle.module" library="service.py"/>
+    <extension point="xbmc.addon.metadata">
+        <summary lang="en">
+            BSPlayer Subtitles
+        </summary>
+        <description lang="en">
+            Search and download various subtitles from the BSPlayer subtitles community.
+        </description>
+        <source>https://github.com/realgam3/service.subtitles.bsplayer</source>
+        <email>realgam3@gmail.com</email>
+        <license>GNU GENERAL PUBLIC LICENSE. Version 2, June 1991</license>
+        <platform>all</platform>
+        <assets>
+            <icon>logo.png</icon>
+        </assets>
+    </extension>
 </addon>
\ No newline at end of file
diff --git a/changelog.txt b/changelog.txt
index bfa041b..bab6f09 100644
--- a/changelog.txt
+++ b/changelog.txt
@@ -1,3 +1,6 @@
+0.3.0 - 15/05/2022
+- Migrating to python 3, support kodi 19
+
 0.2.1 - 07/11/2015
 - Fixed android non rar support, rearrange code
 
diff --git a/resources/__init__.py b/resources/__init__.py
index b93054b..e69de29 100644
--- a/resources/__init__.py
+++ b/resources/__init__.py
@@ -1 +0,0 @@
-# Dummy file to make this directory a package.
diff --git a/resources/lib/bsplayer.py b/resources/lib/bsplayer.py
index 6052322..3042c24 100644
--- a/resources/lib/bsplayer.py
+++ b/resources/lib/bsplayer.py
@@ -1,26 +1,24 @@
 import gzip
+import socket
 import random
 from time import sleep
-from StringIO import StringIO
 from xml.etree import ElementTree
+from urllib.request import Request
 
-from utils import movie_size_and_hash, get_session, log
-
-# s1-9, s101-109
-SUB_DOMAINS = ['s1', 's2', 's3', 's4', 's5', 's6', 's7', 's8', 's9',
-               's101', 's102', 's103', 's104', 's105', 's106', 's107', 's108', 's109']
-API_URL_TEMPLATE = "http://{sub_domain}.api.bsplayer-subtitles.com/v1.php"
-
-
-def get_sub_domain():
-    sub_domains_end = len(SUB_DOMAINS) - 1
-    return API_URL_TEMPLATE.format(sub_domain=SUB_DOMAINS[random.randint(0, sub_domains_end)])
+from .utils import movie_size_and_hash, get_session, log
 
 
 class BSPlayer(object):
+    VERSION = "2.67"
+    DOMAIN = "api.bsplayer-subtitles.com"
+    SUB_DOMAINS = [
+        's1', 's2', 's3', 's4', 's5', 's6', 's7', 's8',
+        's101', 's102', 's103', 's104', 's105', 's106', 's107', 's108', 's109'
+    ]
+
     def __init__(self, search_url=None, proxies=None):
         self.session = get_session(proxies=proxies)
-        self.search_url = search_url or get_sub_domain()
+        self.search_url = search_url or self.get_sub_domain()
         self.token = None
 
     def __enter__(self):
@@ -30,33 +28,43 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         return self.logout()
 
+    def get_sub_domain(self, tries=5):
+        for t in range(tries):
+            domain = f"{random.choice(self.SUB_DOMAINS)}.{self.DOMAIN}"
+            try:
+                socket.gethostbyname(domain)
+                return f"http://{domain}/v1.php"
+            except socket.gaierror:
+                continue
+        raise Exception("API Domain not found")
+
     def api_request(self, func_name='logIn', params='', tries=5):
         headers = {
             'User-Agent': 'BSPlayer/2.x (1022.12360)',
             'Content-Type': 'text/xml; charset=utf-8',
             'Connection': 'close',
-            'SOAPAction': '"http://api.bsplayer-subtitles.com/v1.php#{func_name}"'.format(func_name=func_name)
+            'SOAPAction': f'"http://{self.DOMAIN}/v1.php#{func_name}"'
         }
         data = (
             '<?xml version="1.0" encoding="UTF-8"?>\n'
             '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
             'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
             'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
-            'xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:ns1="{search_url}">'
+            f'xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:ns1="{self.search_url}">'
             '<SOAP-ENV:Body SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
-            '<ns1:{func_name}>{params}</ns1:{func_name}></SOAP-ENV:Body></SOAP-ENV:Envelope>'
-        ).format(search_url=self.search_url, func_name=func_name, params=params)
+            f'<ns1:{func_name}>{params}</ns1:{func_name}></SOAP-ENV:Body></SOAP-ENV:Envelope>'
+        )
 
         log('BSPlayer.api_request', 'Sending request: %s.' % func_name)
-        for i in xrange(tries):
+        for i in range(tries):
             try:
-                self.session.addheaders.extend(headers.items())
-                res = self.session.open(self.search_url, data)
+                req = Request(self.search_url, data=data.encode(), headers=headers, method="POST")
+                res = self.session.open(req)
                 return ElementTree.fromstring(res.read())
-            except Exception, ex:
+            except Exception as ex:
                 log("BSPlayer.api_request", "ERROR: %s." % ex)
                 if func_name == 'logIn':
-                    self.search_url = get_sub_domain()
+                    self.search_url = self.get_sub_domain()
                 sleep(1)
         log('BSPlayer.api_request', 'ERROR: Too many tries (%d)...' % tries)
         raise Exception('Too many tries...')
@@ -68,9 +76,11 @@ def login(self):
 
         root = self.api_request(
             func_name='logIn',
-            params=('<username></username>'
-                    '<password></password>'
-                    '<AppID>BSPlayer v2.67</AppID>')
+            params=(
+                '<username></username>'
+                '<password></password>'
+                f'<AppID>BSPlayer v{self.VERSION}</AppID>'
+            )
         )
         res = root.find('.//return')
         if res.find('status').text == 'OK':
@@ -86,7 +96,7 @@ def logout(self):
 
         root = self.api_request(
             func_name='logOut',
-            params='<handle>{token}</handle>'.format(token=self.token)
+            params=f'<handle>{self.token}</handle>'
         )
         res = root.find('.//return')
         self.token = None
@@ -102,18 +112,21 @@ def search_subtitles(self, movie_path, language_ids='heb,eng', logout=False):
         if isinstance(language_ids, (tuple, list, set)):
             language_ids = ",".join(language_ids)
 
-        movie_size, movie_hash = movie_size_and_hash(movie_path)
-        log('BSPlayer.search_subtitles', 'Movie Size: %s, Movie Hash: %s.' % (movie_size, movie_hash))
+        try:
+            movie_size, movie_hash = movie_size_and_hash(movie_path)
+        except Exception as ex:
+            print(ex)
+            exit(1)
+        log('BSPlayer.search_subtitles', f'Movie Size: {movie_size}, Movie Hash: {movie_hash}.')
         root = self.api_request(
             func_name='searchSubtitles',
             params=(
-                '<handle>{token}</handle>'
-                '<movieHash>{movie_hash}</movieHash>'
-                '<movieSize>{movie_size}</movieSize>'
-                '<languageId>{language_ids}</languageId>'
+                f'<handle>{self.token}</handle>'
+                f'<movieHash>{movie_hash}</movieHash>'
+                f'<movieSize>{movie_size}</movieSize>'
+                f'<languageId>{language_ids}</languageId>'
                 '<imdbId>*</imdbId>'
-            ).format(token=self.token, movie_hash=movie_hash,
-                     movie_size=movie_size, language_ids=language_ids)
+            )
         )
         res = root.find('.//return/result')
         if res.find('status').text != 'OK':
@@ -129,7 +142,8 @@ def search_subtitles(self, movie_path, language_ids='heb,eng', logout=False):
                     subDownloadLink=item.find('subDownloadLink').text,
                     subLang=item.find('subLang').text,
                     subName=item.find('subName').text,
-                    subFormat=item.find('subFormat').text
+                    subFormat=item.find('subFormat').text,
+                    subRating=item.find('subRating').text or '0'
                 ))
 
         if logout:
@@ -141,10 +155,10 @@ def search_subtitles(self, movie_path, language_ids='heb,eng', logout=False):
     def download_subtitles(download_url, dest_path, proxies=None):
         session = get_session(proxies=proxies, http_10=True)
         session.addheaders = [('User-Agent', 'Mozilla/4.0 (compatible; Synapse)'),
-                             ('Content-Length', 0)]
+                              ('Content-Length', 0)]
         res = session.open(download_url)
         if res:
-            gf = gzip.GzipFile(fileobj=StringIO(res.read()))
+            gf = gzip.GzipFile(fileobj=res)
             with open(dest_path, 'wb') as f:
                 f.write(gf.read())
                 f.flush()
diff --git a/resources/lib/utils.py b/resources/lib/utils.py
index 8035de1..fb645db 100644
--- a/resources/lib/utils.py
+++ b/resources/lib/utils.py
@@ -1,30 +1,28 @@
 import sys
 import struct
-import urllib2
-import urlparse
-import cookielib
 from os import path
-from httplib import HTTPConnection
+from urllib import parse, request
+from http.cookiejar import CookieJar
+from http.client import HTTPConnection
 
 import xbmc
-import xbmcvfs
 
 
 def log(module, msg):
-    xbmc.log((u"### [%s] - %s" % (module, msg)).encode('utf-8'), level=xbmc.LOGDEBUG)
+    xbmc.log(f"### [{module}] - {msg}", level=xbmc.LOGDEBUG)
 
 
 def notify(script_name, language, string_id):
-    xbmc.executebuiltin((u'Notification(%s,%s)' % (script_name, language(string_id))).encode('utf-8'))
+    xbmc.executebuiltin(f"Notification({script_name}, {language(string_id)})")
 
 
 def get_params(params_str=""):
     params_str = params_str or sys.argv[2]
-    return dict(urlparse.parse_qsl(params_str.lstrip('?')))
+    return dict(parse.parse_qsl(params_str.lstrip('?')))
 
 
 def get_video_path(xbmc_path=''):
-    xbmc_path = xbmc_path or urlparse.unquote(xbmc.Player().getPlayingFile().decode('utf-8'))
+    xbmc_path = xbmc_path or parse.unquote(xbmc.Player().getPlayingFile())
     if xbmc_path.startswith('rar://'):
         return path.dirname(xbmc_path.replace('rar://', ''))
     elif xbmc_path.startswith('stack://'):
@@ -50,7 +48,7 @@ class HTTP10Connection(HTTPConnection):
     _http_vsn_str = "HTTP/1.0"
 
 
-class HTTP10Handler(urllib2.HTTPHandler):
+class HTTP10Handler(request.HTTPHandler):
     def http_open(self, req):
         return self.do_open(HTTP10Connection, req)
 
@@ -58,13 +56,13 @@ def http_open(self, req):
 def get_session(proxies=None, cookies=True, http_10=False):
     handlers = []
     if proxies:
-        handlers.append(urllib2.ProxyHandler(proxies))
+        handlers.append(request.ProxyHandler(proxies))
     if cookies:
-        cj = cookielib.CookieJar()
-        handlers.append(urllib2.HTTPCookieProcessor(cj))
+        cj = CookieJar()
+        handlers.append(request.HTTPCookieProcessor(cj))
     if http_10:
         handlers.append(HTTP10Handler)
-    return urllib2.build_opener(*handlers)
+    return request.build_opener(*handlers)
 
 
 def __get_last_split(firs_rar_file, x):
@@ -78,7 +76,7 @@ def __get_last_split(firs_rar_file, x):
 
 
 def __add_file_hash(name, file_hash, seek):
-    f = xbmcvfs.File(name)
+    f = open(name, "rb")
     f.seek(max(0, seek), 0)
     for i in range(8192):
         file_hash += struct.unpack('<q', f.read(8))[0]
@@ -89,9 +87,9 @@ def __add_file_hash(name, file_hash, seek):
 
 def __movie_size_and_hash_rar(firs_rar_file):
     log('utils.movie_size_and_hash', 'Hashing Rar file...')
-    f = xbmcvfs.File(firs_rar_file)
+    f = open(firs_rar_file, 'rb')
     a = f.read(4)
-    if a != 'Rar!':
+    if a != b'Rar!':
         log('utils.movie_size_and_hash', 'ERROR: This is not rar file (%s).' % path.basename(firs_rar_file))
         raise Exception('ERROR: This is not rar file.')
     seek = 0
@@ -129,8 +127,8 @@ def movie_size_and_hash(file_path):
     longlong_format = '<q'  # little-endian long long
     byte_size = struct.calcsize(longlong_format)
 
-    f = xbmcvfs.File(file_path)
-    file_size = f.size()
+    file_size = path.getsize(file_path)
+    f = open(file_path, 'rb')
     movie_hash = file_size
 
     if file_size < 65536 * 2:
@@ -138,14 +136,14 @@ def movie_size_and_hash(file_path):
         log('utils.movie_size_and_hash', "ERROR: SizeError (%d)." % file_size)
         raise Exception("SizeError")
 
-    for x in range(65536 / byte_size):
+    for x in range(65536 // byte_size):
         buff = f.read(byte_size)
         (l_value,) = struct.unpack(longlong_format, buff)
         movie_hash += l_value
         movie_hash &= 0xFFFFFFFFFFFFFFFF  # to remain as 64bit number
 
     f.seek(max(0, file_size - 65536), 0)
-    for x in range(65536 / byte_size):
+    for x in range(65536 // byte_size):
         buff = f.read(byte_size)
         (l_value,) = struct.unpack(longlong_format, buff)
         movie_hash += l_value
diff --git a/service.py b/service.py
index 52c1a44..c9d0408 100644
--- a/service.py
+++ b/service.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 import sys
-import urllib
 import shutil
 from os import path
+from urllib import parse
 
 import xbmc
 import xbmcvfs
@@ -20,43 +20,44 @@
 __version__ = __addon__.getAddonInfo('version')
 __language__ = __addon__.getLocalizedString
 
-__cwd__ = xbmc.translatePath(__addon__.getAddonInfo('path')).decode("utf-8")
-__profile__ = xbmc.translatePath(__addon__.getAddonInfo('profile')).decode("utf-8")
-__resource__ = xbmc.translatePath(path.join(__cwd__, 'resources', 'lib')).decode("utf-8")
-__temp__ = xbmc.translatePath(path.join(__profile__, 'temp', '')).decode("utf-8")
-
+__cwd__ = xbmc.translatePath(__addon__.getAddonInfo("path"))
+__profile__ = xbmc.translatePath(__addon__.getAddonInfo("profile"))
+__resource__ = xbmc.translatePath(path.join(__cwd__, "resources", "lib"))
+__temp__ = xbmc.translatePath(path.join(__profile__, "temp", ""))
 
 params = get_params()
-log("BSPlayer.params", "Current Action: %s." % params['action'])
+log(f"BSPlayer.params", f"Current Action: {params['action']}.")
 if params['action'] == 'search':
     video_path = get_video_path()
     if video_path.startswith('http://') or video_path.startswith('https://'):
         notify(__scriptname__, __language__, 32001)
         log("BSPlayer.get_video_path", "Streaming not supported.")
 
-    log("BSPlayer.video_path", "Current Video Path: %s." % video_path)
+    log("BSPlayer.video_path", f"Current Video Path: {video_path}.")
     languages = get_languages_dict(params['languages'])
-    log("BSPlayer.languages", "Current Languages: %s." % languages)
+    log("BSPlayer.languages", f"Current Languages: {languages}.")
 
     with BSPlayer() as bsp:
-        subtitles = bsp.search_subtitles(video_path, language_ids=languages.keys())
+        subtitles = bsp.search_subtitles(video_path, language_ids=list(languages.keys()))
+        log("BSPlayer.subtitles", f"Subtitles found: {subtitles}.")
         for subtitle in sorted(subtitles, key=lambda s: s['subLang']):
             list_item = xbmcgui.ListItem(
                 label=languages[subtitle['subLang']],
                 label2=subtitle['subName'],
-                thumbnailImage=xbmc.convertLanguage(subtitle["subLang"], xbmc.ISO_639_1)
             )
+            list_item.setArt({
+                "icon": f"{float(subtitle['subRating']) / 2}",
+                "thumb": xbmc.convertLanguage(subtitle["subLang"], xbmc.ISO_639_1)
+            })
 
-            plugin_url = "plugin://{path}/?{query}".format(
-                path=__scriptid__,
-                query=urllib.urlencode(dict(
-                    action='download',
-                    link=subtitle['subDownloadLink'],
-                    file_name=subtitle['subName'],
-                    format=subtitle['subFormat']
-                ))
-            )
-            log("BSPlayer.plugin_url", "Plugin Url Created: %s." % plugin_url)
+            query = parse.urlencode(dict(
+                action='download',
+                link=subtitle['subDownloadLink'],
+                file_name=subtitle['subName'],
+                format=subtitle['subFormat']
+            ))
+            plugin_url = f"plugin://{__scriptid__}/?{query}"
+            log("BSPlayer.plugin_url", f"Plugin Url Created: {plugin_url}.")
             xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=plugin_url, listitem=list_item, isFolder=False)
 elif params['action'] == 'manualsearch':
     notify(__scriptname__, __language__, 32002)
@@ -69,9 +70,9 @@
     if params['format'] in ["srt", "sub", "txt", "smi", "ssa", "ass"]:
         subtitle_path = path.join(__temp__, params['file_name'])
         if BSPlayer.download_subtitles(params['link'], subtitle_path):
-            log("BSPlayer.download_subtitles", "Subtitles Download Successfully From: %s." % params['link'])
+            log("BSPlayer.download_subtitles", f"Subtitles Download Successfully From: {params['link']}")
             list_item = xbmcgui.ListItem(label=subtitle_path)
-            log("BSPlayer.download", "Downloaded Subtitle Path: %s" % subtitle_path)
+            log("BSPlayer.download", f"Downloaded Subtitle Path: {subtitle_path}")
             xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=subtitle_path, listitem=list_item, isFolder=False)
 
 xbmcplugin.endOfDirectory(int(sys.argv[1]))