pylookyloo 1.24.0__tar.gz → 1.25.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pylookyloo
-Version: 1.24.0
+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.24.0 → pylookyloo-1.25.0}/pylookyloo/api.py

@@ -2,12 +2,14 @@
 
 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 Any, TypedDict, overload
+from typing import Any, TypedDict, overload, Literal
 from urllib.parse import urljoin, urlparse
 from pathlib import PurePosixPath, Path
 
@@ -283,6 +285,14 @@ class Lookyloo():
         else:
             raise AuthError('Unable to initialize API key')
 
+    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'))))
@@ -433,13 +443,22 @@ class Lookyloo():
         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: CompareSettings | None=None) -> dict[str, Any]:
@@ -464,8 +483,109 @@ class Lookyloo():
         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.24.0 → pylookyloo-1.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pylookyloo"
-version = "1.24.0"
+version = "1.25.0"
 description = "Python CLI and module for Lookyloo"
 authors = ["Raphaël Vinot <raphael.vinot@circl.lu>"]
 license = "BSD-3-Clause"
@@ -31,21 +31,21 @@ lookyloo = 'pylookyloo:main'
 
 [tool.poetry.dependencies]
 python = "^3.8"
-requests = "^2.31.0"
+requests = "^2.32.3"
 Sphinx = [
     {version = "<7.2", python = "<3.9", optional = true},
     {version = "^7.2", python = ">=3.9", optional = true}
 ]
 
 [tool.poetry.group.dev.dependencies]
-mypy = "^1.9.0"
-types-requests = "^2.31.0.20240311"
+mypy = "^1.10.1"
+types-requests = "^2.32.0.20240622"
 ipython = [
     {version = "<8.13.0", python = "<3.9"},
     {version = "^8.18.0", python = ">=3.9"},
     {version = "^8.19.0", python = ">=3.10"}
 ]
-pytest = "^8.1.1"
+pytest = "^8.2.2"
 
 [tool.poetry.extras]
 docs = ["Sphinx"]