pylookyloo 1.23.1__py3-none-any.whl → 1.25.0__py3-none-any.whl

pylookyloo/api.py

@@ -1,12 +1,15 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 
+from __future__ import annotations
+
+import os
 import base64
 import warnings
 
+from datetime import datetime
 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, Literal
 from urllib.parse import urljoin, urlparse
 from pathlib import PurePosixPath, Path
 
@@ -24,39 +27,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 +76,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,7 +87,7 @@ 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.
@@ -94,24 +97,24 @@ class Lookyloo():
         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(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(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(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 +129,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 +264,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(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,12 +285,20 @@ class Lookyloo():
         else:
             raise AuthError('Unable to initialize API key')
 
-    def misp_export(self, tree_uuid: str) -> Dict[str, Any]:
+    def get_user_config(self) -> dict[str, Any] | None:
+        '''Get the configuration enforced by the server for the current user (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(PurePosixPath('json', 'get_user_config'))))
+        return r.json()
+
+    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(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.
         '''
@@ -296,7 +307,7 @@ class Lookyloo():
         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.
         '''
@@ -305,21 +316,21 @@ class Lookyloo():
                               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(PurePosixPath('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(PurePosixPath('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
@@ -327,7 +338,7 @@ class Lookyloo():
         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
@@ -335,7 +346,7 @@ class Lookyloo():
         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
@@ -359,7 +370,7 @@ class Lookyloo():
         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
@@ -382,7 +393,7 @@ 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(PurePosixPath('json', capture_uuid, 'hashes'))), params=params)
         return r.json()
@@ -395,7 +406,7 @@ class Lookyloo():
         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
@@ -403,7 +414,7 @@ class Lookyloo():
         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
@@ -414,7 +425,7 @@ class Lookyloo():
                               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
@@ -426,22 +437,31 @@ class Lookyloo():
                               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(PurePosixPath('json', 'stats'))))
         return r.json()
 
-    def get_takedown_information(self, capture_uuid: str) -> Dict[str, Any]:
+    @overload
+    def get_takedown_information(self, capture_uuid: str, filter_contacts: Literal[True]) -> list[str]:
+        ...
+
+    @overload
+    def get_takedown_information(self, capture_uuid: str, filter_contacts: Literal[False]=False) -> list[dict[str, Any]]:
+        ...
+
+    def get_takedown_information(self, capture_uuid: str, filter_contacts: bool=False) -> list[dict[str, Any]] | list[str]:
         '''Returns information required to request a takedown for a capture
 
         :param capture_uuid: UUID of the capture
+        :param filter_contacts: If True, will only return the contact emails and filter out the invalid ones.
         '''
         r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'takedown'))),
-                              json={'capture_uuid': capture_uuid})
+                              json={'capture_uuid': capture_uuid, 'filter': filter_contacts})
         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
@@ -453,3 +473,119 @@ class Lookyloo():
                                     '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]:
+        '''Reports a capture by sending an email to the investigation team
+
+        :param tree_uuid: UUID of the capture
+        :param email: Email of the reporter, used by the analyst to get in touch
+        :param comment: Description of the URL, will be given to the analyst
+        '''
+        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()
+
+    def get_recent_captures(self, timestamp: str | datetime | float | None=None) -> list[str]:
+        '''Gets the uuids of the most recent captures
+
+        :param timestamp: Timestamp of the capture
+        '''
+        if not timestamp:
+            url = urljoin(self.root_url, str(PurePosixPath('json', 'recent_captures')))
+        else:
+            if isinstance(timestamp, datetime):
+                timestamp = timestamp.timestamp()
+            url = urljoin(self.root_url, str(PurePosixPath('json', 'recent_captures', str(timestamp))))
+        r = self.session.get(url)
+        return r.json()
+
+    @overload
+    def upload_capture(self, *, quiet: Literal[True],
+                       listing: bool = False,
+                       full_capture: Path | BytesIO | str | None = None,
+                       har: Path | BytesIO | str | None = None,
+                       html: Path | BytesIO | str | None = None,
+                       last_redirected_url: str | None = None,
+                       screenshot: Path | BytesIO | str | None = None) -> str:
+        ...
+
+    @overload
+    def upload_capture(self, *, quiet: Literal[False]=False,
+                       listing: bool = False,
+                       full_capture: Path | BytesIO | str | None = None,
+                       har: Path | BytesIO | str | None = None,
+                       html: Path | BytesIO | str | None = None,
+                       last_redirected_url: str | None = None,
+                       screenshot: Path | BytesIO | str | None = None) -> tuple[str, dict[str, str]]:
+        ...
+
+    def upload_capture(self, *, quiet: bool = False,
+                       listing: bool = False,
+                       full_capture: Path | BytesIO | str | None = None,
+                       har: Path | BytesIO | str | None = None,
+                       html: Path | BytesIO | str | None = None,
+                       last_redirected_url: str | None = None,
+                       screenshot: Path | BytesIO | str | None = None) -> str | tuple[str, dict[str, str]]:
+        '''Upload a capture via har-file and others
+
+        :param quiet: Returns the UUID only, instead of the the UUID and the potential error / warning messages
+        :param listing: if true the capture should be public, else private - overwritten if the full_capture is given and it contains no_index
+        :param full_capture: path to the capture made by another instance
+        :param har: Harfile of the capture
+        :param html: rendered HTML of the capture
+        :param last_redirected_url: The landing page of the capture
+        :param screenshot: Screenshot of the capture
+        '''
+        def encode_document(document: Path | BytesIO | str) -> str:
+            if isinstance(document, str):
+                if not os.path.exists(document):
+                    raise FileNotFoundError(f'{document} does not exist')
+                document = Path(document)
+            if isinstance(document, Path):
+                with document.open('rb') as f:
+                    document = BytesIO(f.read())
+            return base64.b64encode(document.getvalue()).decode()
+
+        to_send: dict[str, Any] = {'listing': listing}
+
+        if full_capture:
+            b64_full_capture = encode_document(full_capture)
+            to_send['full_capture'] = b64_full_capture
+        elif har:
+            b64_har = encode_document(har)
+            to_send['har_file'] = b64_har
+
+            if html:
+                b64_html = encode_document(html)
+                to_send['html_file'] = b64_html
+
+            if last_redirected_url:
+                to_send['landing_page'] = last_redirected_url
+
+            if screenshot:
+                b64_screenshot = encode_document(screenshot)
+                to_send['screenshot_file'] = b64_screenshot
+        else:
+            raise PyLookylooError("Full capture or at least har-file are required")
+
+        r = self.session.post(urljoin(self.root_url, str(PurePosixPath('json', 'upload'))), json=to_send)
+        r.raise_for_status()
+        json_response = r.json()
+        uuid = json_response['uuid']
+        messages = json_response['messages']
+
+        if not uuid:
+            raise PyLookylooError('Unable to get UUID from lookyloo instance.')
+        if quiet:
+            return uuid
+        return uuid, messages

{pylookyloo-1.23.1.dist-info → pylookyloo-1.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pylookyloo
-Version: 1.23.1
+Version: 1.25.0
 Summary: Python CLI and module for Lookyloo
 Home-page: https://github.com/lookyloo/PyLookyloo
 License: BSD-3-Clause
@@ -25,7 +25,7 @@ Classifier: Topic :: Security
 Provides-Extra: docs
 Requires-Dist: Sphinx (<7.2) ; (python_version < "3.9") and (extra == "docs")
 Requires-Dist: Sphinx (>=7.2,<8.0) ; (python_version >= "3.9") and (extra == "docs")
-Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
 Project-URL: Documentation, https://pylookyloo.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/lookyloo/PyLookyloo
 Description-Content-Type: text/markdown

pylookyloo-1.25.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pylookyloo/__init__.py,sha256=_JYXwXHL7ShZkeruvGd8qDTpxNRfuDjvV65SOMMU6yc,1922
+pylookyloo/api.py,sha256=YLMcYNZa9kE0U-3v569amCUtRKUWSGphHf1BPu4Zs1I,27335
+pylookyloo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pylookyloo-1.25.0.dist-info/LICENSE,sha256=4C4hLYrIkUD96Ggk-y_Go1Qf7PBZrEm9PSeTGe2nd4s,1516
+pylookyloo-1.25.0.dist-info/METADATA,sha256=GCazh6CEBrAsHOMVxlaZTx-alAU2H4YNSQUHrAIb5Qs,2340
+pylookyloo-1.25.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pylookyloo-1.25.0.dist-info/entry_points.txt,sha256=y2c0Ujg8co6Xyf7MoxStVU-fLQMZBSGAg-KFidmsha4,44
+pylookyloo-1.25.0.dist-info/RECORD,,

{pylookyloo-1.23.1.dist-info → pylookyloo-1.25.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pylookyloo-1.23.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-pylookyloo/__init__.py,sha256=_JYXwXHL7ShZkeruvGd8qDTpxNRfuDjvV65SOMMU6yc,1922
-pylookyloo/api.py,sha256=pUNC0DoaxYlvhOkDKHF4bSqRwABiCv1UkZgPz8zRIBM,21392
-pylookyloo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pylookyloo-1.23.1.dist-info/LICENSE,sha256=4C4hLYrIkUD96Ggk-y_Go1Qf7PBZrEm9PSeTGe2nd4s,1516
-pylookyloo-1.23.1.dist-info/METADATA,sha256=qltwCMFtvxCE5IO22c5uEaAukdc1l0h_hSEFVdoRI6Q,2340
-pylookyloo-1.23.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-pylookyloo-1.23.1.dist-info/entry_points.txt,sha256=y2c0Ujg8co6Xyf7MoxStVU-fLQMZBSGAg-KFidmsha4,44
-pylookyloo-1.23.1.dist-info/RECORD,,