jwlib 1.0.0__py3-none-any.whl

jwlib/__init__.py

@@ -0,0 +1,2 @@
+__version__ = '1.0.0'
+

jwlib/common.py

@@ -0,0 +1,85 @@
+"""
+Utility functions shared across jwlib
+"""
+from __future__ import annotations
+
+import json
+import logging
+import urllib.error
+import urllib.parse
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+
+class NotFoundError(Exception):
+    """Raised when the server returns HTTP 404"""
+
+
+class _DictWrapper:
+    """Wraps server response data"""
+
+    data: dict
+    """Object data as returned by the server.
+
+    If you need access to information that has no getter method, you can get it here.
+
+    .. note::
+        Editing this directory is an untested feature.
+    """
+
+    def __init__(self, data: dict):
+        if not isinstance(data, dict):
+            raise TypeError(f'{self.__class__} cannot be initialized with {type(data)}')
+        self.data = data
+
+    def _get_int(self, key, default: int = 0):
+        try:
+            return int(self.data[key])
+        except (KeyError, TypeError, ValueError):
+            if default is not None:
+                logger.debug('%s contains invalid data', self, exc_info=True)
+                return default
+            raise
+
+    def _get_float(self, key, default: float = 0.0):
+        try:
+            return float(self.data[key])
+        except (KeyError, TypeError, ValueError):
+            if default is not None:
+                logger.debug('%s contains invalid data', self, exc_info=True)
+                return default
+            raise
+
+    def _get_string(self, key, default: str | None = None) -> str:
+        """Return a non-zero string"""
+
+        value = self.data.get(key)
+        if not isinstance(value, str) or value == '':
+            if default is not None:
+                logger.debug(f'{self} contains invalid data', exc_info=True)
+                return default
+            raise
+
+        return value
+
+
+def _get_json(url: str, query: dict | None = None, *, headers: dict | None = None):
+    """Send a query to the server and return loaded JSON"""
+
+    if query:
+        # Remove None, convert bool to int
+        query = {k: (int(v) if isinstance(v, bool) else v)
+                 for k, v in query.items()
+                 if v is not None}
+        url += '?' + urllib.parse.urlencode(query)
+
+    logger.debug(f'opening: {url}')
+
+    r = urllib.request.Request(url, headers=headers or {})
+    try:
+        return json.load(urllib.request.urlopen(r))
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            raise NotFoundError from e
+        raise

jwlib/media/__init__.py

@@ -0,0 +1,34 @@
+"""
+Wrappers for the "mediator" API used in the video section at `jw.org <http://jw.org>`_.
+
+The common way to start is to create a :class:`Session` in your language
+of choice, use :meth:`~Session.get_category` to get the root and
+work your way from there using :meth:`~Category.get_subcategories` and
+:meth:`~Category.get_media`:
+
+.. doctest::
+
+    >>> import jwlib.media as jw
+    >>> english_session = jw.Session()
+    >>> root = english_session.get_category()
+    >>> for category in root.get_subcategories():
+    >>>     for media in category.get_media():
+    >>>         print(media.title)
+"""
+
+from ..common import NotFoundError
+from .const import *
+from .endpoints import request_translations
+from .language import Language, request_languages
+from .session import Category, File, Media, Session
+
+__all__ = (
+    'Session',
+    'Category',
+    'Media',
+    'File',
+    'Language',
+    'request_languages',
+    'request_translations',
+    'NotFoundError'
+)

jwlib/media/const.py

@@ -0,0 +1,143 @@
+"""
+Constants used in the mediator API
+"""
+
+# General
+# =======
+
+# Category.key of the root category.
+# This is not part of the mediator API, it belongs to jwlib.
+ROOT_CATEGORY = 'All'
+
+# Time format used by the API, can be passed to time.strptime()
+TIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
+
+# Client type
+# ===========
+# These can be passed to Session().
+# They affect what data will be made available.
+
+CLIENT_APPLETV = 'appletv'
+CLIENT_FIRETV = 'firetv'  # Default in jwlib.
+CLIENT_JWORG = 'JWORG'
+CLIENT_NONE = 'none'  # Includes obscure categories and convention releases (slow).
+CLIENT_ROKU = 'roku'
+CLIENT_RWLS = 'rwls'
+CLIENT_SATELLITE = 'satellite'
+CLIENT_WWW = 'www'  # Used by jw.org.
+
+# Category type
+# =============
+CATEGORY_CONTAINER = 'container'
+CATEGORY_ONDEMAND = 'ondemand'
+
+# Media type
+# ==========
+MEDIA_AUDIO = 'audio'
+MEDIA_VIDEO = 'video'
+
+# Image selection
+# ===============
+# These can be passed to get_image().
+# Ratios are sorted from large-ish to small-ish.
+
+RATIOS_SQUARE = ('sqr', 'sqs', 'cvr')
+RATIOS_16_9 = ('wsr', 'wss')
+RATIOS_2_1 = ('lsr', 'lss')
+RATIOS_3_1 = ('pnr',)
+
+SIZES_FROM_SMALLEST = ('xs', 'sm', 'md', 'lg', 'xl')
+SIZES_FROM_LARGEST = tuple(reversed(SIZES_FROM_SMALLEST))
+
+# Tags
+# ====
+# These are found in Category.tags or Media.tags.
+
+# Used by jw.org for subcategories with a Play button.
+TAG_ALLOW_PLAY_ALL_AS_ICONS_IN_GRID = 'AllowPlayAllAsIconsInGrid'
+TAG_ALLOW_PLAY_ALL_IN_CATEGORY_HEADER = 'AllowPlayAllInCategoryHeader'
+
+# Used by jw.org for subcategories with a Shuffle button.
+TAG_ALLOW_SHUFFLE_AS_ICONS_IN_GRID = 'AllowShuffleAsIconsInGrid'
+TAG_ALLOW_SHUFFLE_IN_CATEGORY_HEADER = 'AllowShuffleInCategoryHeader'
+
+# Convention release media item (excluded automatically by many client types).
+TAG_CONVENTION_RELEASE = 'ConventionRelease'
+
+# Note:
+# You normally don't have to check for the EXCLUDE tags.
+# For example, if your client type is CLIENT_APPLETV it will automatically
+# exclude items tagged TAG_EXCLUDE_APPLETV.
+
+TAG_EXCLUDE_ALL_VIDEOS = 'AllVideosExclude'
+TAG_EXCLUDE_APPLETV = 'AppleTVExclude'
+TAG_EXCLUDE_FIRETV = 'FireTVExclude'
+TAG_EXCLUDE_FROM_BREADCRUMBS = 'ExcludeFromBreadcrumbs'
+TAG_EXCLUDE_JWL = 'JWLExclude'
+TAG_EXCLUDE_JWL_CATALOG = 'JWLCatalogExclude'
+TAG_EXCLUDE_JWORG = 'JWORGExclude'
+TAG_EXCLUDE_LATEST = 'LatestVideosExclude'
+TAG_EXCLUDE_LIBRARY = 'LibraryVideosExclude'
+TAG_EXCLUDE_ROKU = 'RokuExclude'
+TAG_EXCLUDE_RWLS = 'RWLSExclude'
+TAG_EXCLUDE_SATELLITE = 'SatelliteExclude'
+TAG_EXCLUDE_SEARCH = 'SearchExclude'
+TAG_EXCLUDE_WEB = 'WebExclude'
+TAG_EXCLUDE_WWW = 'WWWExclude'
+TAG_EXCLUDE_WWW_CAT_LIST = 'WWWCatListExclude'
+
+# Used by StudioFeatured.
+TAG_FEATURED = 'WebFeatured'
+
+TAG_INCLUDE_IN_JWORG_ALL_VIDEOS_CAT_LIST = 'IncludeInJWORGAllVideosCatList'
+
+TAG_INCLUDE_SUB_CATEGORIES_NAV_RWLS = 'RWLSIncludeSubCategoriesAsNav'
+TAG_INCLUDE_SUB_CATEGORIES_NAV_WEB = 'WebIncludeSubCategoriesInNav'
+TAG_INCLUDE_SUB_CATEGORIES_NAV_WWW = 'WWWIncludeSubCategoriesAsNav'
+
+TAG_PNR_FEATURED_LAYOUT = 'PNRFeaturedLayout'
+
+# Used by audio categories, since the album covers are square.
+TAG_PREFER_SQUARE_IMAGES = 'PreferSquareImages'
+
+TAG_ROKU_CATEGORY_CAROUSEL_LIST = 'RokuCategoryCarouselList'
+TAG_ROKU_CATEGORY_GRID = 'RokuCategoryGrid'
+TAG_ROKU_CATEGORY_GRID_SCREEN = 'RokuCategoryGridScreen'
+TAG_ROKU_CATEGORY_SELECTION_POSTER_SCREEN = 'RokuCategorySelectionPosterScreen'
+TAG_ROKU_GRID_STYLE_SQUARE = 'RokuGridStyleSquare'
+TAG_ROKU_MEDIA_ITEM_LIST_SCREEN = 'RokuMediaItemListScreen'
+
+# Used by jw.org for main categories with a Shuffle button.
+TAG_STREAM_THIS_CHANNEL_ENABLED = 'StreamThisChannelEnabled'
+
+TAG_SUPPRESS_TOP_CATEGORY_BANNER = 'SuppressTopCategoryBanner'
+
+# Limit number of items in the list.
+TAGS_ITEM_LIMIT = (
+    'LimitToZero',
+    'LimitToOne',  # Used by FeaturedLibraryVideos.
+    'LimitToTwo',  # Used by StudioFeatured.
+    'LimitToThree',
+    'LimitToFour',
+    'LimitToFive',  # Used by FeaturedSetTopBoxes.
+    'LimitToSix',
+    'LimitToSeven',
+    'LimitToEight',
+    'LimitToNine',
+    'LimitToTen',
+)
+
+# Month of release.
+TAGS_MONTH = (
+    'Month01',
+    'Month02',
+    'Month03',
+    'Month04',
+    'Month05',
+    'Month06',
+    'Month07',
+    'Month08',
+    'Month09',
+    'Month10',
+    'Month11',
+    'Month12')

jwlib/media/endpoints.py

@@ -0,0 +1,120 @@
+"""
+Functions for the different API endpoints
+"""
+from __future__ import annotations
+
+from ..common import NotFoundError, _get_json
+from .const import CATEGORY_CONTAINER, CLIENT_NONE, ROOT_CATEGORY
+
+_API_BASE = 'https://b.jw-cdn.org/apis/mediator/v1'
+
+
+def _request_category_data(language: str, key: str, *, client: str, include_media: bool, media_list_offset=0) -> dict:
+    """Request category data from the server"""
+
+    # If this is called for ROOT_CATEGORY it means we're trying to refresh() it
+    if key == ROOT_CATEGORY:
+        return _root_category_dict(subcategories=_request_top_categories(language, client))
+
+    query = {
+        'clientType': client if client != CLIENT_NONE else None,
+        # detailed controls whether subcategories will be included in the response
+        # None means no, anything else means yes
+        'detailed': 1,
+        # offset controls at which index the media list will start
+        # this is useful in case the total length is larger than 'limit'
+        'offset': (media_list_offset or None) if include_media else None,
+        # limit controls the max length of the media list
+        # None means the server will decide
+        'limit': None if include_media else 0,
+        # mediaLimit controls the max length of the media list inside subcategories
+        # None means the server will decide
+        'mediaLimit': None if include_media else 0,
+    }
+    try:
+        response = _get_json(f'{_API_BASE}/categories/{language}/{key}', query)
+        category_data = response['category']
+        if not isinstance(category_data, dict):
+            raise TypeError(f'expected dict, got {type(category_data)}')
+    except (NotFoundError, KeyError, TypeError) as e:
+        raise NotFoundError(f'{language}/{key}') from e
+
+    # Save the total number of media items available, it may be used later for pagination
+    # (this is only available for type 'ondemand' categories)
+    try:
+        category_data['_paginationTotalCount'] = response['pagination']['totalCount']
+    except (KeyError, TypeError):
+        pass
+
+    # If we requested no media items for subcategories, we must make the subcategories aware of this
+    # so that calls to get_media() doesn't think there is actually no media.
+    if include_media is False:
+        for subcategory_data in category_data.get('subcategories', []):
+            try:
+                subcategory_data['_paginationLimit'] = 0
+            except TypeError:
+                pass
+
+    return category_data
+
+
+def _request_top_categories(language: str, client: str) -> list[dict]:
+    """Request list of top-level categories from the server"""
+
+    # Never call this with detailed=1
+    # It results in 'subcategories': {} which is a TypeError (should be a list)
+    # This is a bug on the server side
+    query = {'clientType': client if client != CLIENT_NONE else None}
+    try:
+        response = _get_json(f'{_API_BASE}/categories/{language}', query)
+        top_level_list = response['categories']
+        if not isinstance(top_level_list, list):
+            raise TypeError(f'expected list, got {type(top_level_list)}')
+    except (NotFoundError, KeyError, TypeError) as e:
+        raise NotFoundError(f'{language}') from e
+    return top_level_list
+
+
+def _root_category_dict(**kwargs) -> dict:
+    """Return a dict with root category data
+
+    The server has no 'root' category, it's just a list of top-level categories. But we make one to
+    make things more convenient and also give it a 'key' to not produce empty values for templates.
+
+    We use a function return a unique object each time, instead of just having this as a global constant,
+    since dicts are mutable that could (and have) messed things up during testing.
+    """
+    return dict(
+        description='Top-level category of all video and audio categories',
+        images={},
+        key=ROOT_CATEGORY,
+        name='All Categories',
+        tags=[],
+        type=CATEGORY_CONTAINER,
+        **kwargs
+    )
+
+
+def _request_media_data(language: str, key: str, *, client: str) -> dict:
+    """Request media data from the server"""
+
+    try:
+        query = {'clientType': client if client != CLIENT_NONE else None}
+        response = _get_json(f'{_API_BASE}/media-items/{language}/{key}', query)
+        media_data = response['media'][0]
+    # It seems to return HTTP 200 with a response of [] if the item doesn't exist...
+    except (NotFoundError, TypeError, KeyError, IndexError) as e:
+        raise NotFoundError(f'{language}/{key}') from e
+    return media_data
+
+
+def _request_languages(language: str) -> list[dict]:
+    """Request list of language data from the server"""
+
+    return _get_json(f'{_API_BASE}/languages/{language}/web')['languages']
+
+
+def request_translations(language: str) -> dict:
+    """Return a dict of string IDs and translated string used at the website"""
+
+    return _get_json(f'{_API_BASE}/translations/{language}')['translations'][language]

jwlib/media/imagetable.py

@@ -0,0 +1,212 @@
+"""Script that generates an image format table.
+
+The values from the table can be fed into :meth:`~jwlib.media.Media.get_image`.
+
+.. rubric:: Category images
+
++---------+--------------+---------------+--------------+-----------------------------+
+| ratio   | dimensions   | ratio alias   | size alias   | available for client type   |
++=========+==============+===============+==============+=============================+
+| 1:1     | 50x50        | sqs           | xs           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 75x75        | sqs           | sm           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 100x100      | sqr           | xs           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 120x120      | sqr           | sm           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 125x125      | sqs           | md           | none                        |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 200x200      | sqs           | lg           | none                        |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 224x224      | sqr           | md           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 342x342      | sqr           | lg           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 1:1     | 600x600      | sqr           | xl           | none                        |
++---------+--------------+---------------+--------------+-----------------------------+
+| 269:152 | 269x152      | wsr           | xs           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 160x90       | wss           | xs           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 320x180      | wss           | sm           | firetv, none, roku, www     |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 640x360      | wss           | lg           | appletv, none               |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 640x360      | wsr           | sm           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 720x405      | wsr           | md           | none                        |
++---------+--------------+---------------+--------------+-----------------------------+
+| 16:9    | 1280x720     | wsr           | lg           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 3:1     | 240x80       | pnr           | xs           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 3:1     | 480x160      | pnr           | sm           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 3:1     | 801x267      | pnr           | md           | none, roku                  |
++---------+--------------+---------------+--------------+-----------------------------+
+| 3:1     | 1200x400     | pnr           | lg           | appletv, none, roku, www    |
++---------+--------------+---------------+--------------+-----------------------------+
+
+.. rubric:: Media images
+
++---------+--------------+---------------+--------------+----------------------------------+
+| ratio   | dimensions   | ratio alias   | size alias   | available for client type        |
++=========+==============+===============+==============+==================================+
+| 1:1     | 50x50        | sqs           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 1:1     | 100x100      | sqr           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 1:1     | 120x120      | sqr           | sm           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 1:1     | 160x160      | cvr           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 1:1     | 224x224      | sqr           | md           | appletv, none, roku              |
++---------+--------------+---------------+--------------+----------------------------------+
+| 1:1     | 342x342      | sqr           | lg           | firetv, roku, www                |
++---------+--------------+---------------+--------------+----------------------------------+
+| 269:152 | 269x152      | wsr           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 16:9    | 160x90       | wss           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 16:9    | 320x180      | wss           | sm           | appletv, none, roku, www         |
++---------+--------------+---------------+--------------+----------------------------------+
+| 16:9    | 640x360      | wss           | lg           | appletv, firetv, none, www       |
++---------+--------------+---------------+--------------+----------------------------------+
+| 16:9    | 640x360      | wsr           | sm           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 16:9    | 1280x720     | wsr           | lg           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 2:1     | 760x380      | lss           | lg           | www                              |
++---------+--------------+---------------+--------------+----------------------------------+
+| 2:1     | 1200x600     | lsr           | xl           | none, www                        |
++---------+--------------+---------------+--------------+----------------------------------+
+| 3:1     | 240x80       | pnr           | xs           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 3:1     | 480x160      | pnr           | sm           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 3:1     | 801x267      | pnr           | md           | roku                             |
++---------+--------------+---------------+--------------+----------------------------------+
+| 3:1     | 1200x400     | pnr           | lg           | appletv, firetv, none, roku, www |
++---------+--------------+---------------+--------------+----------------------------------+
+
+You can generate an up-to-date version by running::
+
+    python -m jwlib.media.imagetable [CLIENT_TYPE] ...
+
+.. note::
+    This requires `Pillow` and `tabulate` to be installed.
+"""
+import sys
+from fractions import Fraction
+from typing import Dict, NamedTuple, Set
+from urllib.request import urlopen
+
+from .const import CLIENT_APPLETV, CLIENT_FIRETV, CLIENT_NONE, CLIENT_ROKU, CLIENT_WWW
+from .session import Session
+
+__all__ = (
+    'generate_image_table',
+)
+
+
+def generate_image_table(*client_types: str) -> None:
+    # We import these here so Sphinx doesn't need to install them
+    # to generate the documentation
+    from PIL import Image
+    from tabulate import tabulate
+
+    if not client_types:
+        client_types = CLIENT_NONE, CLIENT_APPLETV, CLIENT_FIRETV, CLIENT_ROKU, CLIENT_WWW
+
+    class ImageType(NamedTuple):
+        ratio_alias: str
+        size_alias: str
+
+    class ClientsWhereImageTypeIsAvailable(Set[str]):
+        def __str__(self):
+            return ', '.join(sorted(self))
+
+    ClientAvailabilityMap = Dict[ImageType, ClientsWhereImageTypeIsAvailable]
+
+    class Dimensions(NamedTuple):
+        x: int
+        y: int
+
+        @classmethod
+        def from_url(cls, url):
+            print(url)
+            with urlopen(url) as response:
+                x, y = Image.open(response).size
+                return cls(x, y)
+
+        def __str__(self):
+            return f'{self.x}x{self.y}'
+
+        def as_fraction(self):
+            return Fraction(self.x, self.y)
+
+        def formatted_ratio(self):
+            fraction = self.as_fraction()
+            return f'{fraction.numerator}:{fraction.denominator}'
+
+    dimension_map: Dict[ImageType, Dimensions] = {}
+    category_image_availability: ClientAvailabilityMap = {}
+    media_image_availability: ClientAvailabilityMap = {}
+
+    def parse_images(images: dict, availability_map: ClientAvailabilityMap, client: str) -> None:
+        for ratio_alias in images:
+            for size_alias in images[ratio_alias]:
+                url = images[ratio_alias][size_alias]
+                if not url:
+                    continue
+                image_type = ImageType(ratio_alias, size_alias)
+                if image_type not in dimension_map:
+                    dimension_map[image_type] = Dimensions.from_url(url)
+                if image_type not in availability_map:
+                    availability_map[image_type] = ClientsWhereImageTypeIsAvailable()
+                availability_map[image_type].add(client)
+
+    for client_name in client_types:
+        session = Session(client_type=client_name)
+
+        cat = session.get_category('VODStudio')
+        parse_images(cat.data['images'], category_image_availability, client_name)
+
+        media = next(next(cat.get_subcategories()).get_media())
+        parse_images(media.data['images'], media_image_availability, client_name)
+
+    headers = ['ratio', 'dimensions', 'ratio alias', 'size alias', 'available for client type']
+
+    class Row(NamedTuple):
+        formatted_ratio: str
+        dimensions: Dimensions
+        ratio_alias: str
+        size_alias: str
+        clients: ClientsWhereImageTypeIsAvailable
+
+    def create_rows(availability_map: ClientAvailabilityMap):
+        for image_type, available_clients in availability_map.items():
+            dimensions = dimension_map[image_type]
+            yield Row(
+                formatted_ratio=dimensions.formatted_ratio(),
+                dimensions=dimensions,
+                ratio_alias=image_type.ratio_alias,
+                size_alias=image_type.size_alias,
+                clients=available_clients
+            )
+
+    def row_sort_function(row: Row):
+        return row.dimensions.as_fraction(), row.dimensions
+
+    print('\n.. rubric:: Category images')
+    rows_category = sorted(create_rows(category_image_availability), key=row_sort_function)
+    print(tabulate(rows_category, headers=headers, tablefmt='grid'))
+
+    print('\n.. rubric:: Media images')
+    rows_media = sorted(create_rows(media_image_availability), key=row_sort_function)
+    print(tabulate(rows_media, headers=headers, tablefmt='grid'))
+
+
+if __name__ == '__main__':
+    generate_image_table(*sys.argv[1:])

jwlib/media/language.py

@@ -0,0 +1,65 @@
+"""
+Language list and info
+"""
+from __future__ import annotations
+
+from ..common import _DictWrapper
+from .endpoints import _request_languages
+
+__all__ = 'request_languages', 'Language'
+
+
+def request_languages(language='E') -> list[Language]:
+    """Return list of available Languages"""
+
+    return [Language(L) for L in _request_languages(language)]
+
+
+class Language(_DictWrapper):
+    """Information about a language"""
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__} {self.code!r}>'
+
+    @property
+    def code(self) -> str:
+        """JW language code
+
+        The one that can be passed to :class:`Session` etc.
+        """
+        return self._get_string('code')
+
+    @property
+    def iso(self) -> str:
+        """ISO 639 language code"""
+        return self._get_string('locale')
+
+    @property
+    def name(self) -> str:
+        """Display name"""
+        return self._get_string('name', '')
+
+    # This seems to always be False
+    # @property
+    # def pair(self) -> bool:
+    #    return self.dict.get('isLangPair', False)
+
+    @property
+    def rtl(self) -> bool:
+        """True if written right to left"""
+        return self.data.get('isRTL', False)
+
+    @property
+    def script(self) -> str:
+        """Type of script, like 'ROMAN' or 'CYRILLIC'"""
+        return self._get_string('script', '')
+
+    @property
+    def signed(self) -> bool:
+        """True if it's a sign language"""
+        return self.data.get('isSignLanguage', False)
+
+    @property
+    def vernacular(self) -> str:
+        """Display name in the language itself"""
+        return self._get_string('vernacular', '')