mediacatch 0.0.1__py3-none-any.whl

mediacatch/__init__.py

@@ -0,0 +1,17 @@
+import logging
+import sys
+import os
+
+from dotenv import load_dotenv
+
+logging.basicConfig(
+    format='[%(asctime)s][%(levelname)s][%(name)s] %(message)s',
+    datefmt='%d/%m/%Y-%H:%M:%S',
+    handlers=[logging.StreamHandler(sys.stdout)],
+    level=logging.INFO,
+)
+
+load_dotenv()
+mediacatch_api_key = os.environ['MEDIACATCH-API-KEY']
+
+__version__ = '0.0.1'

mediacatch/commands/__init__.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser
+
+
+class BaseCLICommand(ABC):
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(parser: ArgumentParser):
+        raise NotImplementedError()
+
+    @staticmethod
+    def run(self):
+        raise NotImplementedError()

mediacatch/commands/cli.py

@@ -0,0 +1,31 @@
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+
+from mediacatch.commands.vision import VisionCLI
+
+
+def main():
+    parser = ArgumentParser(
+        prog='MediaCatch CLI tool',
+        usage='mediacatch <command> [<args>]',
+        description='MediaCatch CLI tool',
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    commands_parser = parser.add_subparsers(help='mediacatch command helpers')
+
+    # Register commands
+    VisionCLI.register_subcommand(commands_parser)
+
+    # Let's go
+    args = parser.parse_args()
+
+    if not hasattr(args, 'func'):
+        parser.print_help()
+        exit(1)
+
+    # Run
+    service = args.func(args)
+    service.run()
+
+
+if __name__ == '__main__':
+    main()

mediacatch/commands/vision.py

@@ -0,0 +1,157 @@
+import json
+import logging
+from argparse import ArgumentParser
+from pathlib import Path
+from pprint import pprint
+
+from mediacatch.commands import BaseCLICommand
+from mediacatch.vision import upload, wait_for_result
+
+logger = logging.getLogger('mediacatch.cli.vision')
+
+
+def vision_cli_factory(args):
+    return VisionCLI(
+        file_path=args.file_path,
+        type=args.type,
+        save_result=args.save_result,
+        fps=args.fps,
+        tolerance=args.tolerance,
+        min_levensthein_ratio=args.min_levensthein_ratio,
+        min_bbox_iou=args.min_bbox_iou,
+        min_text_confidence=args.min_text_confidence,
+        max_text_confidence=args.max_text_confidence,
+        max_text_length=args.max_text_length,
+        moving_text_threshold=args.moving_text_threshold,
+    )
+
+
+class VisionCLI(BaseCLICommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        vision_parser: ArgumentParser = parser.add_parser(
+            'vision', help='CLI tool to run inference with MediaCatch Vision API'
+        )
+        vision_parser.add_argument(
+            'file_path', type=str, help='Path to the file to run inference on'
+        )
+        vision_parser.add_argument(
+            'type',
+            type=str,
+            choices=['ocr', 'face'],
+            help='Type of inference to run on the file',
+        )
+        vision_parser.add_argument(
+            '--save-result',
+            type=str,
+            default=None,
+            help='Save result to a file',
+        )
+        vision_parser.add_argument(
+            '--fps',
+            type=int,
+            default=None,
+            help='FPS for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--tolerance',
+            type=int,
+            default=None,
+            help='Tolerance for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--min-levensthein-ratio',
+            type=float,
+            default=None,
+            help='Minimum Levenshtein ratio for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--min-bbox-iou',
+            type=float,
+            default=None,
+            help='Minimum bounding box IOU for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--min-text-confidence',
+            type=float,
+            default=None,
+            help='Minimum text confidence for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--max-text-confidence',
+            type=float,
+            default=None,
+            help='Maximum text confidence for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--max-text-length',
+            type=int,
+            default=None,
+            help='Maximum text length for the OCR results',
+        )
+        vision_parser.add_argument(
+            '--moving-text-threshold',
+            type=int,
+            default=None,
+            help='Moving text threshold for the OCR results',
+        )
+        vision_parser.set_defaults(func=vision_cli_factory)
+
+    def __init__(
+        self,
+        file_path: str,
+        type: str,
+        save_result: str | None = None,
+        fps: int | None = None,
+        tolerance: int | None = None,
+        min_levensthein_ratio: float | None = None,
+        min_bbox_iou: float | None = None,
+        min_text_confidence: float | None = None,
+        max_text_confidence: float | None = None,
+        max_text_length: int | None = None,
+        moving_text_threshold: int | None = None,
+    ) -> None:
+        self.file_path = file_path
+        self.type = type
+        self.save_result = save_result
+        self.fps = fps
+        self.tolerance = tolerance
+        self.min_levensthein_ratio = min_levensthein_ratio
+        self.min_bbox_iou = min_bbox_iou
+        self.min_text_confidence = min_text_confidence
+        self.max_text_confidence = max_text_confidence
+        self.max_text_length = max_text_length
+        self.moving_text_threshold = moving_text_threshold
+
+    def run(self) -> None:
+        # Create extra parameters
+        extra = {}
+        for k, val in (
+            ('fps', self.fps),
+            ('tolerance', self.tolerance),
+            ('min_levensthein_ratio', self.min_levensthein_ratio),
+            ('min_bbox_iou', self.min_bbox_iou),
+            ('min_text_confidence', self.min_text_confidence),
+            ('max_text_confidence', self.max_text_confidence),
+            ('max_text_length', self.max_text_length),
+            ('moving_text_threshold', self.moving_text_threshold),
+        ):
+            if val is not None:
+                extra[k] = val
+
+        # Upload file to MediaCatch Vision API
+        file_id = upload(self.file_path, self.type, extra=extra)
+
+        # Wait for result
+        result = wait_for_result(file_id)
+        if not result:
+            logger.error('Failed to get result from MediaCatch Vision API')
+            return
+
+        logger.info('Results:')
+        pprint(result)
+
+        # Save result to a file
+        if self.save_result:
+            Path(self.save_result).write_text(json.dumps(result, indent=4))
+            logger.info(f'Result saved to {self.save_result}')

mediacatch/utils/general.py

@@ -0,0 +1,38 @@
+import json
+import os
+import logging
+
+import requests
+
+logger = logging.getLogger('mediacatch.utils.general')
+
+
+def get_data_from_url(url: str) -> dict:
+    """Get data from a URL.
+
+    Args:
+        url (str): The URL to get data from.
+
+    Returns:
+        dict: Data dictionary from url.
+    """
+    logger.info(f'Getting data from {url}')
+    response = requests.get(url)
+    assert response.status_code == 200, f'Failed to get data from {url}: {response}'
+    return response.json()
+
+
+def load_data_from_json(json_file: str) -> dict:
+    """Load data from a JSON file.
+
+    Args:
+        json_file (str): JSON file with data.
+
+    Returns:
+        dict: Data dictionary from JSON file.
+    """
+    logger.info(f'Loading data from {json_file}')
+    assert os.path.isfile(json_file), f'File {json_file} does not exist'
+    with open(json_file, 'r') as f:
+        result = json.load(f)
+    return result

mediacatch/vision/__init__.py

@@ -0,0 +1,2 @@
+from mediacatch.vision.result import wait_for_result
+from mediacatch.vision.upload import upload

mediacatch/vision/result.py

@@ -0,0 +1,49 @@
+import json
+import logging
+import time
+from typing import Any
+
+import requests
+
+logger = logging.getLogger('mediacatch.vision.result')
+
+
+def wait_for_result(
+    file_id: str,
+    url: str = 'https://api.mediacatch.io/vision',
+    timeout: int = 3600,
+    delay: int = 30,
+) -> dict[str, Any] | None:
+    """Wait for result from a URL.
+
+    Args:
+        file_id (str): The file ID to get the result from.
+        url (str): The URL to get the result from.
+        timeout (int, optional): Timeout for waiting in seconds. Defaults to 3600.
+        delay (int, optional): Delay between each request. Defaults to 5.
+
+    Returns:
+        dict[str, Any] | None: Dictionary with the result from the URL or None if failed.
+    """
+    result_url = f'{url}/result/{file_id}'
+    logger.info(f'Waiting for result from {result_url}')
+    start_time = time.time()
+    end_time = start_time + timeout
+    while time.time() < end_time:
+        try:
+            response = requests.get(result_url)
+            response.raise_for_status()
+            result = response.json()
+            elapsed_time = time.time() - start_time
+            logger.info(f'Got result from {result_url} in {elapsed_time:.2f} seconds')
+            return result
+
+        except (requests.RequestException, json.JSONDecodeError):
+            time.sleep(delay)
+
+        except Exception as e:
+            logger.error(f'Failed to get result from {result_url}: {e}')
+            return None
+
+    logger.error(f'Timeout waiting for result from {result_url}, give up')
+    return None

mediacatch/vision/upload.py

@@ -0,0 +1,57 @@
+import json
+import logging
+from typing import Any, Literal
+
+import requests
+
+from mediacatch import mediacatch_api_key
+
+logger = logging.getLogger('mediacatch.vision.upload')
+
+headers = {
+    'accept': 'application/json',
+    'Content-Type': 'application/json',
+    'X-API-KEY': f'{mediacatch_api_key}',
+}
+
+
+def upload(
+    fpath: str,
+    type: Literal['ocr', 'face'],
+    url: str = 'https://api.mediacatch.io/vision',
+    extra: dict[str, Any] = {},
+) -> str:
+    """Upload a file to MediaCatch Vision API.
+
+    Args:
+        fpath (str): File path.
+        type (Literal['ocr', 'face']): Type of inference to run on the file.
+        url (str, optional): URL to the vision API. Defaults to 'https://api.mediacatch.io/vision'.
+        extra (dict[str, Any], optional): Dictonary with extra parameters. Defaults to {}.
+
+    Returns:
+        str: File ID.
+    """
+    logger.info(f'Uploading file {fpath} to MediaCatch Vision API')
+
+    # Get presigned URL
+    data = {'filename': fpath, 'type': type, 'extra': extra}
+    response = requests.post(f'{url}/upload/', headers=headers, data=json.dumps(data))
+    assert (
+        response.status_code == 201
+    ), f'Failed to upload file {fpath} to MediaCatch Vision API: {response.text}'
+    response_data = response.json()
+    file_id = response_data['file_id']
+
+    # Upload file to storage
+    with open(fpath, 'rb') as f:
+        files = {'file': (response_data['fields']['key'], f)}
+        response = requests.post(response_data['url'], data=response_data['fields'], files=files)
+
+    # Mark file as uploaded
+    data = {'file_id': file_id}
+    response = requests.post(f'{url}/upload/complete/', headers=headers, data=json.dumps(data))
+    assert response.status_code == 200, f'Failed to mark file {fpath} as uploaded: {response}'
+
+    logger.info(f'File {fpath} uploaded with ID {file_id}')
+    return file_id

mediacatch-0.0.1.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.3
+Name: mediacatch
+Version: 0.0.1
+Summary: Python package for easily interfacing with MediaCatch APIs and data formats.
+Project-URL: Documentation, https://github.com/mediacatch/mediacatch#readme
+Project-URL: Issues, https://github.com/mediacatch/mediacatch/issues
+Project-URL: Source, https://github.com/mediacatch/mediacatch
+Author-email: Mathias Nielsen <mathias@mediacatch.io>, Frederik Haarslev <frederik@mediacatch.io>
+License-Expression: MIT
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: opencv-python-headless
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == 'docs'
+Requires-Dist: mkdocs-autorefs; extra == 'docs'
+Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: mkdocstrings; extra == 'docs'
+Requires-Dist: mkdocstrings-python; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: black; extra == 'test'
+Requires-Dist: hatch; extra == 'test'
+Requires-Dist: isort; extra == 'test'
+Requires-Dist: mypy; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+# MediaCatch
+
+Python package for easily interfacing with MediaCatch APIs and data formats.
+
+## Installation
+
+TBD.
+
+## Getting Started
+
+TBD.

mediacatch-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+mediacatch/__init__.py,sha256=lEBSAh9l0XQjT2AkMs5BlwOSN87eGQMSk7BH7-tRHu8,356
+mediacatch/commands/__init__.py,sha256=vTLJOd4n5aVy9Z_fG4kZLzcr9kuSylR4666bo3S0L_E,302
+mediacatch/commands/cli.py,sha256=guEeLrCLAh__HxplDdSDOYE8uWdD633ko9xtJD7bvoI,727
+mediacatch/commands/vision.py,sha256=IxslHvk3pYXMaPfH5t9Y_Hq56Tm0IguqsA9EOgaa2xU,5215
+mediacatch/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mediacatch/utils/general.py,sha256=E4emyI2jN1u7ZrBDL5wHhOpiHJ8jPyl-GzaZTvuXB0M,906
+mediacatch/vision/__init__.py,sha256=hX_1CPm81KVuP5kqoIwLbf2Mas35cfWLV_kHIxPuUCg,97
+mediacatch/vision/result.py,sha256=wY5RaOWJxd9hhc93GJHqTzfYatOt4-viHWuHKE3AT9E,1546
+mediacatch/vision/upload.py,sha256=SSfwdI6pk5DomvR_MwI5NyKWTVcgmUw8cz_AE6_kR5o,1867
+mediacatch-0.0.1.dist-info/METADATA,sha256=2lKp1o189fz8_E_I8dLIIz40rn-RSHrwaZV3sfjb6w8,2009
+mediacatch-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mediacatch-0.0.1.dist-info/entry_points.txt,sha256=gYOMlPb97KioFnzzNDzDhLBcM-AXwTTah-amIzl_kac,60
+mediacatch-0.0.1.dist-info/RECORD,,

mediacatch-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mediacatch-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mediacatch = mediacatch.commands.cli:main