pylookyloo 1.23.0__tar.gz → 1.24.0__tar.gz

{pylookyloo-1.23.0 → pylookyloo-1.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pylookyloo
-Version: 1.23.0
+Version: 1.24.0
 Summary: Python CLI and module for Lookyloo
 Home-page: https://github.com/lookyloo/PyLookyloo
 License: BSD-3-Clause

{pylookyloo-1.23.0 → pylookyloo-1.24.0}/pylookyloo/api.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
+
+from __future__ import annotations
 
 import base64
 import warnings
 
 from importlib.metadata import version
 from io import BytesIO, StringIO
-from typing import Optional, Dict, Any, List, Union, TypedDict, overload
+from typing import Any, TypedDict, overload
 from urllib.parse import urljoin, urlparse
-from pathlib import Path
+from pathlib import PurePosixPath, Path
 
 import requests
 
@@ -24,39 +25,39 @@ class AuthError(PyLookylooError):
 class CaptureSettings(TypedDict, total=False):
     '''The capture settings that can be passed to Lookyloo.'''
 
-    url: Optional[str]
-    document_name: Optional[str]
-    document: Optional[str]
-    browser: Optional[str]
-    device_name: Optional[str]
-    user_agent: Optional[str]
-    proxy: Optional[Union[str, Dict[str, str]]]
-    general_timeout_in_sec: Optional[int]
-    cookies: Optional[List[Dict[str, Any]]]
-    headers: Optional[Union[str, Dict[str, str]]]
-    http_credentials: Optional[Dict[str, int]]
-    geolocation: Optional[Dict[str, float]]
-    timezone_id: Optional[str]
-    locale: Optional[str]
-    color_scheme: Optional[str]
-    viewport: Optional[Dict[str, int]]
-    referer: Optional[str]
-
-    listing: Optional[bool]
-    auto_report: Optional[Union[bool, Dict[str, str]]]
+    url: str | None
+    document_name: str | None
+    document: str | None
+    browser: str | None
+    device_name: str | None
+    user_agent: str | None
+    proxy: str | dict[str, str] | None
+    general_timeout_in_sec: int | None
+    cookies: list[dict[str, Any]] | None
+    headers: str | dict[str, str] | None
+    http_credentials: dict[str, int] | None
+    geolocation: dict[str, float] | None
+    timezone_id: str | None
+    locale: str | None
+    color_scheme: str | None
+    viewport: dict[str, int] | None
+    referer: str | None
+
+    listing: bool | None
+    auto_report: bool | dict[str, str] | None
 
 
 class CompareSettings(TypedDict, total=False):
     '''The settings that can be passed to the compare method on lookyloo side to filter out some differences'''
 
-    ressources_ignore_domains: Optional[List[str]]
-    ressources_ignore_regexes: Optional[List[str]]
+    ressources_ignore_domains: list[str] | None
+    ressources_ignore_regexes: list[str] | None
 
 
 class Lookyloo():
 
-    def __init__(self, root_url: str='https://lookyloo.circl.lu/', useragent: Optional[str]=None,
-                 *, proxies: Optional[Dict[str, str]]=None):
+    def __init__(self, root_url: str='https://lookyloo.circl.lu/', useragent: str | None=None,
+                 *, proxies: dict[str, str] | None=None):
         '''Query a specific lookyloo instance.
 
         :param root_url: URL of the instance to query.
@@ -73,7 +74,7 @@ class Lookyloo():
         self.session.headers['user-agent'] = useragent if useragent else f'PyLookyloo / {version("pylookyloo")}'
         if proxies:
             self.session.proxies.update(proxies)
-        self.apikey: Optional[str] = None
+        self.apikey: str | None = None
 
     @property
     def is_up(self) -> bool:
@@ -84,34 +85,34 @@ class Lookyloo():
             return False
         return r.status_code == 200
 
-    def get_status(self, tree_uuid: str) -> Dict[str, Any]:
+    def get_status(self, tree_uuid: str) -> dict[str, Any]:
         '''Get the status of a capture:
             * -1: Unknown capture.
             * 0: The capture is queued up but not processed yet.
             * 1: The capture is ready.
             * 2: The capture is ongoing and will be ready soon.
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'status'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'status'))))
         return r.json()
 
-    def get_capture_stats(self, tree_uuid: str) -> Dict[str, Any]:
+    def get_capture_stats(self, tree_uuid: str) -> dict[str, Any]:
         '''Get statistics of the capture'''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'stats'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'stats'))))
         return r.json()
 
-    def get_info(self, tree_uuid: str) -> Dict[str, Any]:
+    def get_info(self, tree_uuid: str) -> dict[str, Any]:
         '''Get information about the capture (url, timestamp, user agent)'''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'info'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'info'))))
         return r.json()
 
-    def get_comparables(self, tree_uuid: str) -> Dict[str, Any]:
+    def get_comparables(self, tree_uuid: str) -> dict[str, Any]:
         '''Get comparable information from the capture'''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'comparables'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'comparables'))))
         return r.json()
 
-    def enqueue(self, url: Optional[str]=None, quiet: bool=False,  # type: ignore[no-untyped-def]
-                document: Optional[Union[Path, BytesIO]]=None,
-                document_name: Optional[str]=None, **kwargs) -> str:
+    def enqueue(self, url: str | None=None, quiet: bool=False,  # type: ignore[no-untyped-def]
+                document: Path | BytesIO | None=None,
+                document_name: str | None=None, **kwargs) -> str:
         '''Enqueue an URL.
 
         :param url: URL to enqueue
@@ -126,50 +127,50 @@ class Lookyloo():
 
     @overload
     def submit(self, *, quiet: bool=False,
-               capture_settings: Optional[CaptureSettings]=None) -> str:
+               capture_settings: CaptureSettings | None=None) -> str:
         ...
 
     @overload
     def submit(self, *, quiet: bool=False,
-               url: Optional[str]=None,
-               document_name: Optional[str]=None, document: Optional[Union[Path, BytesIO]]=None,
-               browser: Optional[str]=None, device_name: Optional[str]=None,
-               user_agent: Optional[str]=None,
-               proxy: Optional[Union[str, Dict[str, str]]]=None,
-               general_timeout_in_sec: Optional[int]=None,
-               cookies: Optional[List[Dict[str, Any]]]=None,
-               headers: Optional[Union[str, Dict[str, str]]]=None,
-               http_credentials: Optional[Dict[str, int]]=None,
-               geolocation: Optional[Dict[str, float]]=None,
-               timezone_id: Optional[str]=None,
-               locale: Optional[str]=None,
-               color_scheme: Optional[str]=None,
-               viewport: Optional[Dict[str, int]]=None,
-               referer: Optional[str]=None,
-               listing: Optional[bool]=None,
-               auto_report: Optional[Union[bool, Dict[str, str]]]=None
+               url: str | None=None,
+               document_name: str | None=None, document: Path | BytesIO | None=None,
+               browser: str | None=None, device_name: str | None=None,
+               user_agent: str | None=None,
+               proxy: str | dict[str, str] | None=None,
+               general_timeout_in_sec: int | None=None,
+               cookies: list[dict[str, Any]] | None=None,
+               headers: str | dict[str, str] | None=None,
+               http_credentials: dict[str, int] | None=None,
+               geolocation: dict[str, float] | None=None,
+               timezone_id: str | None=None,
+               locale: str | None=None,
+               color_scheme: str | None=None,
+               viewport: dict[str, int] | None=None,
+               referer: str | None=None,
+               listing: bool | None=None,
+               auto_report: bool | dict[str, str] | None=None
                ) -> str:
         ...
 
     def submit(self, *, quiet: bool=False,
-               capture_settings: Optional[CaptureSettings]=None,
-               url: Optional[str]=None,
-               document_name: Optional[str]=None, document: Optional[Union[Path, BytesIO]]=None,
-               browser: Optional[str]=None, device_name: Optional[str]=None,
-               user_agent: Optional[str]=None,
-               proxy: Optional[Union[str, Dict[str, str]]]=None,
-               general_timeout_in_sec: Optional[int]=None,
-               cookies: Optional[List[Dict[str, Any]]]=None,
-               headers: Optional[Union[str, Dict[str, str]]]=None,
-               http_credentials: Optional[Dict[str, int]]=None,
-               geolocation: Optional[Dict[str, float]]=None,
-               timezone_id: Optional[str]=None,
-               locale: Optional[str]=None,
-               color_scheme: Optional[str]=None,
-               viewport: Optional[Dict[str, int]]=None,
-               referer: Optional[str]=None,
-               listing: Optional[bool]=None,
-               auto_report: Optional[Union[bool, Dict[str, str]]]=None
+               capture_settings: CaptureSettings | None=None,
+               url: str | None=None,
+               document_name: str | None=None, document: Path | BytesIO | None=None,
+               browser: str | None=None, device_name: str | None=None,
+               user_agent: str | None=None,
+               proxy: str | dict[str, str] | None=None,
+               general_timeout_in_sec: int | None=None,
+               cookies: list[dict[str, Any]] | None=None,
+               headers: str | dict[str, str] | None=None,
+               http_credentials: dict[str, int] | None=None,
+               geolocation: dict[str, float] | None=None,
+               timezone_id: str | None=None,
+               locale: str | None=None,
+               color_scheme: str | None=None,
+               viewport: dict[str, int] | None=None,
+               referer: str | None=None,
+               listing: bool | None=None,
+               auto_report: bool | dict[str, str] | None=None
                ) -> str:
         '''Submit a URL to a lookyloo instance.
 
@@ -261,13 +262,13 @@ class Lookyloo():
             return uuid
         return urljoin(self.root_url, f'tree/{uuid}')
 
-    def get_apikey(self, username: str, password: str) -> Dict[str, str]:
+    def get_apikey(self, username: str, password: str) -> dict[str, str]:
         '''Get the API key for the given user.'''
         to_post = {'username': username, 'password': password}
-        r = self.session.post(urljoin(self.root_url, str(Path('json', 'get_token'))), json=to_post)
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'get_token'))), json=to_post)
         return r.json()
 
-    def init_apikey(self, username: Optional[str]=None, password: Optional[str]=None, apikey: Optional[str]=None) -> None:
+    def init_apikey(self, username: str | None=None, password: str | None=None, apikey: str | None=None) -> None:
         '''Init the API key for the current session. All the requests against lookyloo after this call will be authenticated.'''
         if apikey:
             self.apikey = apikey
@@ -282,65 +283,65 @@ class Lookyloo():
         else:
             raise AuthError('Unable to initialize API key')
 
-    def misp_export(self, tree_uuid: str) -> Dict[str, Any]:
+    def misp_export(self, tree_uuid: str) -> dict[str, Any]:
         '''Export the capture in MISP format'''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'misp_export'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'misp_export'))))
         return r.json()
 
-    def misp_push(self, tree_uuid: str) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    def misp_push(self, tree_uuid: str) -> dict[str, Any] | list[dict[str, Any]]:
         '''Push the capture to a pre-configured MISP instance (requires an authenticated user, use init_apikey first)
         Note: if the response is a dict, it is an error mesage. If it is a list, it's a list of MISP event.
         '''
         if not self.apikey:
             raise AuthError('You need to initialize the apikey to use this method (see init_apikey)')
-        r = self.session.get(urljoin(self.root_url, str(Path('json', tree_uuid, 'misp_push'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'misp_push'))))
         return r.json()
 
-    def trigger_modules(self, tree_uuid: str, force: bool=False) -> Dict[str, Any]:
+    def trigger_modules(self, tree_uuid: str, force: bool=False) -> dict[str, Any]:
         '''Trigger all the available 3rd party modules on the given capture.
         :param force: Trigger the modules even if they were already triggered today.
         '''
         to_send = {'force': force}
-        r = self.session.post(urljoin(self.root_url, str(Path('json', tree_uuid, 'trigger_modules'))),
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'trigger_modules'))),
                               json=to_send)
         return r.json()
 
-    def rebuild_capture(self, tree_uuid: str) -> Dict[str, str]:
+    def rebuild_capture(self, tree_uuid: str) -> dict[str, str]:
         '''Force rebuild a capture (requires an authenticated user, use init_apikey first)'''
         if not self.apikey:
             raise AuthError('You need to initialize the apikey to use this method (see init_apikey)')
-        r = self.session.get(urljoin(self.root_url, str(Path('admin', tree_uuid, 'rebuild'))))
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('admin', tree_uuid, 'rebuild'))))
         return r.json()
 
-    def hide_capture(self, tree_uuid: str) -> Dict[str, str]:
+    def hide_capture(self, tree_uuid: str) -> dict[str, str]:
         '''Hide a capture from the index page (requires an authenticated user, use init_apikey first)'''
         if not self.apikey:
             raise AuthError('You need to initialize the apikey to use this method (see init_apikey)')
-        r = self.session.get(urljoin(self.root_url, str(Path('admin', tree_uuid, 'hide'))))
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('admin', tree_uuid, 'hide'))))
         return r.json()
 
-    def get_redirects(self, capture_uuid: str) -> Dict[str, Any]:
+    def get_redirects(self, capture_uuid: str) -> dict[str, Any]:
         '''Returns the initial redirects.
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', capture_uuid, 'redirects'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', capture_uuid, 'redirects'))))
         return r.json()
 
-    def get_urls(self, capture_uuid: str) -> Dict[str, Any]:
+    def get_urls(self, capture_uuid: str) -> dict[str, Any]:
         '''Returns all the URLs seen during the capture.
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', capture_uuid, 'urls'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', capture_uuid, 'urls'))))
         return r.json()
 
-    def get_hostnames(self, capture_uuid: str) -> Dict[str, Any]:
+    def get_hostnames(self, capture_uuid: str) -> dict[str, Any]:
         '''Returns all the hostnames seen during the capture.
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', capture_uuid, 'hostnames'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', capture_uuid, 'hostnames'))))
         return r.json()
 
     def get_screenshot(self, capture_uuid: str) -> BytesIO:
@@ -348,7 +349,7 @@ class Lookyloo():
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('bin', capture_uuid, 'screenshot'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('bin', capture_uuid, 'screenshot'))))
         return BytesIO(r.content)
 
     def get_data(self, capture_uuid: str) -> BytesIO:
@@ -356,15 +357,15 @@ class Lookyloo():
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('bin', capture_uuid, 'data'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('bin', capture_uuid, 'data'))))
         return BytesIO(r.content)
 
-    def get_cookies(self, capture_uuid: str) -> List[Dict[str, str]]:
+    def get_cookies(self, capture_uuid: str) -> list[dict[str, str]]:
         '''Returns the complete cookies jar.
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', capture_uuid, 'cookies'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', capture_uuid, 'cookies'))))
         return r.json()
 
     def get_html(self, capture_uuid: str) -> StringIO:
@@ -372,7 +373,7 @@ class Lookyloo():
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('tree', capture_uuid, 'html'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('tree', capture_uuid, 'html'))))
         return StringIO(r.text)
 
     def get_hashes(self, capture_uuid: str, algorithm: str='sha512', hashes_only: bool=True) -> StringIO:
@@ -382,9 +383,9 @@ class Lookyloo():
         :param algorithm: The algorithm of the hashes
         :param hashes_only: If False, will also return the URLs related to the hashes
         '''
-        params: Dict[str, Union[str, int]] = {'algorithm': algorithm, 'hashes_only': int(hashes_only)}
+        params: dict[str, str | int] = {'algorithm': algorithm, 'hashes_only': int(hashes_only)}
 
-        r = self.session.get(urljoin(self.root_url, str(Path('json', capture_uuid, 'hashes'))), params=params)
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', capture_uuid, 'hashes'))), params=params)
         return r.json()
 
     def get_complete_capture(self, capture_uuid: str) -> BytesIO:
@@ -392,29 +393,29 @@ class Lookyloo():
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('bin', capture_uuid, 'export'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('bin', capture_uuid, 'export'))))
         return BytesIO(r.content)
 
-    def get_hash_occurrences(self, h: str) -> Dict[str, Any]:
+    def get_hash_occurrences(self, h: str) -> dict[str, Any]:
         '''Returns the base 64 body related the the hash, and a list of all the captures containing that hash.
 
         :param h: sha512 to search
         '''
-        r = self.session.get(urljoin(self.root_url, str(Path('json', 'hash_info', h))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', 'hash_info', h))))
         return r.json()
 
-    def get_url_occurrences(self, url: str, limit: int=20, cached_captures_only: bool=True) -> Dict[str, Any]:
+    def get_url_occurrences(self, url: str, limit: int=20, cached_captures_only: bool=True) -> dict[str, Any]:
         '''Returns all the captures contining the URL
 
         :param url: URL to lookup
         :param limit: The max amount of entries to return.
         :param cached_captures_only: If False, Lookyloo will attempt to re-cache the missing captures. It might take some time.
         '''
-        r = self.session.post(urljoin(self.root_url, str(Path('json', 'url_info'))), json={'url': url,
-                                                                                           'limit': limit})
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'url_info'))),
+                              json={'url': url, 'limit': limit})
         return r.json()
 
-    def get_hostname_occurrences(self, hostname: str, with_urls_occurrences: bool=False, limit: int=20, cached_captures_only: bool=True) -> Dict[str, Any]:
+    def get_hostname_occurrences(self, hostname: str, with_urls_occurrences: bool=False, limit: int=20, cached_captures_only: bool=True) -> dict[str, Any]:
         '''Returns all the captures contining the hostname. It will be pretty slow on very common domains.
 
         :param hostname: Hostname to lookup
@@ -422,35 +423,49 @@ class Lookyloo():
         :param limit: The max amount of entries to return.
         :param cached_captures_only: If False, Lookyloo will attempt to re-cache the missing captures. It might take some time.
         '''
-        r = self.session.post(urljoin(self.root_url, str(Path('json', 'hostname_info'))), json={'hostname': hostname,
-                                                                                                'with_urls_occurrences': with_urls_occurrences,
-                                                                                                'limit': limit})
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'hostname_info'))),
+                              json={'hostname': hostname, 'with_urls_occurrences': with_urls_occurrences, 'limit': limit})
         return r.json()
 
-    def get_stats(self) -> Dict[str, Any]:
+    def get_stats(self) -> dict[str, Any]:
         '''Returns all the captures contining the URL'''
 
-        r = self.session.get(urljoin(self.root_url, str(Path('json', 'stats'))))
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', 'stats'))))
         return r.json()
 
-    def get_takedown_information(self, capture_uuid: str) -> Dict[str, Any]:
+    def get_takedown_information(self, capture_uuid: str) -> dict[str, Any]:
         '''Returns information required to request a takedown for a capture
 
         :param capture_uuid: UUID of the capture
         '''
-        r = self.session.post(urljoin(self.root_url, str(Path('json', 'takedown'))),
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'takedown'))),
                               json={'capture_uuid': capture_uuid})
         return r.json()
 
-    def compare_captures(self, capture_left: str, capture_right: str, /, *, compare_settings: Optional[CompareSettings]=None) -> Dict[str, Any]:
+    def compare_captures(self, capture_left: str, capture_right: str, /, *, compare_settings: CompareSettings | None=None) -> dict[str, Any]:
         '''Compares two captures
 
         :param capture_left: UUID of the capture to compare from
         :param capture_right: UUID of the capture to compare to
         :param compare_settings: The settings for the comparison itself (what to ignore without marking the captures as different)
         '''
-        r = self.session.post(urljoin(self.root_url, str(Path('json', 'compare_captures'))),
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'compare_captures'))),
                               json={'capture_left': capture_left,
                                     'capture_right': capture_right,
                                     'compare_settings': compare_settings})
         return r.json()
+
+    def get_modules_responses(self, tree_uuid: str) -> dict[str, Any]:
+        '''Returns information from the 3rd party modules
+
+        :param capture_uuid: UUID of the capture
+        '''
+        r = self.session.get(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'modules'))))
+        return r.json()
+
+    def send_mail(self, tree_uuid: str, email: str = '', comment: str | None = None) -> bool | dict[str, Any]:
+        to_send = {'email': email}
+        if comment:
+            to_send['comment'] = comment
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', tree_uuid, 'report'))), json=to_send)
+        return r.json()

{pylookyloo-1.23.0 → pylookyloo-1.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pylookyloo"
-version = "1.23.0"
+version = "1.24.0"
 description = "Python CLI and module for Lookyloo"
 authors = ["Raphaël Vinot <raphael.vinot@circl.lu>"]
 license = "BSD-3-Clause"
@@ -38,14 +38,14 @@ Sphinx = [
 ]
 
 [tool.poetry.group.dev.dependencies]
-mypy = "^1.8.0"
-types-requests = "^2.31.0.20240125"
+mypy = "^1.9.0"
+types-requests = "^2.31.0.20240311"
 ipython = [
     {version = "<8.13.0", python = "<3.9"},
     {version = "^8.18.0", python = ">=3.9"},
     {version = "^8.19.0", python = ">=3.10"}
 ]
-pytest = "^8.0.0"
+pytest = "^8.1.1"
 
 [tool.poetry.extras]
 docs = ["Sphinx"]