mediacatch 0.0.1__tar.gz

mediacatch-0.0.1/.github/workflows/check.yaml

@@ -0,0 +1,34 @@
+name: Quality Check
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: "pip"
+          cache-dependency-path: pyproject.toml
+      - uses: actions/cache@v3
+        id: cache
+        with:
+          path: ${{ env.pythonLocation }}
+          key: ${{ runner.os }}-python-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml') }}-check
+      - name: Install build dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: pip install ".[dev]"
+      - name: Run library checks
+        run: ruff .

mediacatch-0.0.1/.github/workflows/publish.yaml

@@ -0,0 +1,33 @@
+name: Publish
+
+on:
+  release:
+    types:
+      - released
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: "pip"
+          cache-dependency-path: pyproject.toml
+      - uses: actions/cache@v3
+        id: cache
+        with:
+          path: ${{ env.pythonLocation }}
+          key: ${{ runner.os }}-python-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml') }}-publish
+      - name: Install build dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: pip install --upgrade build hatchling pkginfo
+      - name: Build distribution
+        run: python -m build
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@v1.6.4
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          verbose: true

mediacatch-0.0.1/.github/workflows/test.yaml

@@ -0,0 +1,34 @@
+name: Unit Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: "pip"
+          cache-dependency-path: pyproject.toml
+      - uses: actions/cache@v3
+        id: cache
+        with:
+          path: ${{ env.pythonLocation }}
+          key: ${{ runner.os }}-python-${{ env.pythonLocation }}-${{ hashFiles('pyproject.toml') }}-test
+      - name: Install build dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: pip install ".[test]"
+      - name: Run tests
+        run: pytest

mediacatch-0.0.1/.gitignore

@@ -0,0 +1,151 @@
+data
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+.ruff_cache
+
+### VisualStudioCode ###
+.vscode/*
+.vscode/settings.json
+.vscode/tasks.json
+.vscode/launch.json
+.vscode/extensions.json
+.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide

mediacatch-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,11 @@
+# MediaCatch
+
+Python package for easily interfacing with MediaCatch APIs and data formats.
+
+## Installation
+
+TBD.
+
+## Getting Started
+
+TBD.

mediacatch-0.0.1/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-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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/mediacatch/vision/__init__.py

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

mediacatch-0.0.1/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-0.0.1/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/pyproject.toml

@@ -0,0 +1,140 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.urls]
+Documentation = "https://github.com/mediacatch/mediacatch#readme"
+Issues = "https://github.com/mediacatch/mediacatch/issues"
+Source = "https://github.com/mediacatch/mediacatch"
+
+[tool.hatch.version]
+path = "mediacatch/__init__.py"
+
+[project]
+name = "mediacatch"
+description = "Python package for easily interfacing with MediaCatch APIs and data formats."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Mathias Nielsen", email = "mathias@mediacatch.io" },
+    { name = "Frederik Haarslev", email = "frederik@mediacatch.io" },
+]
+classifiers = [
+  "Topic :: Internet",
+  "Topic :: Software Development :: Libraries :: Application Frameworks",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Software Development",
+  "Framework :: FastAPI",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+]
+dynamic = ["version"]
+scripts = { mediacatch = "mediacatch.commands.cli:main" }
+dependencies = [
+    "requests",
+    "opencv-python-headless",
+    "pydantic",
+    "python-dotenv",
+]
+
+[project.optional-dependencies]
+test = ["pytest", "ruff", "black", "isort", "mypy", "hatch"]
+dev = ["ruff", "black", "isort", "mypy", "hatch"]
+docs = [
+  "mkdocs",
+  "mkdocs-material",
+  "mkdocstrings",
+  "mkdocstrings-python",
+  "mkdocs-autorefs",
+]
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 100
+indent-width = 4
+
+# Assume Python 3.10
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Like Black, use single quotes for strings.
+quote-style = "single"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]
+pythonpath = ['.']

mediacatch-0.0.1/tests/test_main.py

@@ -0,0 +1,2 @@
+def test_dummy():
+    assert True