ucapi 0.5.2__tar.gz → 0.7.0__tar.gz

{ucapi-0.5.2 → ucapi-0.7.0}/CHANGELOG.md

@@ -11,6 +11,27 @@ _Changes in the next release_
 
 ---
 
+## v0.7.0 - 2026-05-10
+### Added
+- Add requests for supported entity types, version and localization. Only send available entities with supported entity types by @albaintor and @kennymc-c ([#47](https://github.com/unfoldedcircle/integration-python-library/pull/47)).
+
+### Changed
+- Improved WS msg processing with dedicated consumer, producer and router tasks with asyncio queues ([#47](https://github.com/unfoldedcircle/integration-python-library/pull/47)).
+- Sanitize log messages to prevent sensitive information exposure ([#56](https://github.com/unfoldedcircle/integration-python-library/pull/56)).
+- Log WebSocket messages as JSON data instead of a Python dict ([#58](https://github.com/unfoldedcircle/integration-python-library/pull/58)).
+- Updated GitHub actions and test dependencies.
+
+## v0.6.0 - 2026-04-10
+### Breaking Changes
+- Renamed `MediaType` to `MediaContentType` and changed enums to lowercase. See media-player entity documentation for more information ([#50](https://github.com/unfoldedcircle/integration-python-library/pull/50)).
+- Changed `str, Enum` to new Python 3.11 `StrEnum` class ([#54](https://github.com/unfoldedcircle/integration-python-library/pull/54)).
+- All entity constructors require named parameters for the optional fields ([#49](https://github.com/unfoldedcircle/integration-python-library/pull/49), [#54](https://github.com/unfoldedcircle/integration-python-library/pull/54)).
+
+### Added
+- Media browsing and searching features to media-player entity ([#50](https://github.com/unfoldedcircle/integration-python-library/pull/50)).
+- Allow integrations to provide entity icon and description ([#55](https://github.com/unfoldedcircle/integration-python-library/pull/55)).
+
+
 ## v0.5.2 - 2026-01-30
 ### Added
 - Add Select Entity support by @JackJPowell ([#44](https://github.com/unfoldedcircle/integration-python-library/pull/44)).

{ucapi-0.5.2/ucapi.egg-info → ucapi-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucapi
-Version: 0.5.2
+Version: 0.7.0
 Summary: Python wrapper for the Unfolded Circle Integration API
 Author-email: Unfolded Circle ApS <hello@unfoldedcircle.com>
 License: MPL-2.0
@@ -10,7 +10,7 @@ Project-URL: Bug Reports, https://github.com/unfoldedcircle/integration-python-l
 Project-URL: Discord, http://unfolded.chat/
 Project-URL: Forum, https://unfolded.community/
 Platform: any
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Operating System :: OS Independent

{ucapi-0.5.2 → ucapi-0.7.0}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 license = {text = "MPL-2.0"}
 description = "Python wrapper for the Unfolded Circle Integration API"
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
     "Operating System :: OS Independent",

ucapi-0.7.0/scripts/git-tag.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Git tag release script to simplify creating git tags with changelog since last release.
+Copyright (c) 2026 Unfolded Circle.
+"""
+
+import os
+import subprocess
+import sys
+import tempfile
+import re
+import json
+
+
+def run_command(command, check=True):
+    """Run a shell command and return the output."""
+    try:
+        result = subprocess.run(
+            command, shell=True, check=check, capture_output=True, text=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        print(f"Error running command: {command}")
+        print(f"Stdout: {e.stdout}")
+        print(f"Stderr: {e.stderr}")
+        if check:
+            sys.exit(1)
+        return None
+
+
+def get_latest_tag():
+    """Get the latest git tag."""
+    return run_command("git describe --tags --abbrev=0", check=False)
+
+
+def get_commits_since(tag):
+    """Get commits since the specified tag."""
+    format_str = '--pretty=format:"%s|%an"'
+    if tag:
+        return run_command(f"git log {tag}..HEAD {format_str}")
+    else:
+        return run_command(f"git log {format_str}")
+
+
+def is_valid_semver(tag):
+    """Check if the version is a valid semver format (X.Y.Z)."""
+    return re.match(r"^\d+\.\d+\.\d+$", tag) is not None
+
+
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Git tag script to simplify creating git tags."
+    )
+    parser.add_argument(
+        "version", help="The new version in semver format (e.g., 0.21.0)"
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true", help="Do not create or push the tag"
+    )
+    args = parser.parse_args()
+
+    version = args.version
+    dry_run = args.dry_run
+    if not is_valid_semver(version):
+        print(f"Error: Version '{version}' is not in valid semver format (X.Y.Z)")
+        sys.exit(1)
+
+    new_tag = f"v{version}"
+
+    # Check if tag already exists
+    existing_tags = run_command("git tag").split("\n")
+    if new_tag in existing_tags:
+        print(f"Error: Tag '{new_tag}' already exists.")
+        sys.exit(1)
+
+    latest_tag = get_latest_tag()
+    print(f"Latest tag: {latest_tag}")
+
+    if latest_tag:
+        commits = get_commits_since(latest_tag)
+    else:
+        commits = get_commits_since(None)
+
+    if not commits:
+        print("No commits since last tag.")
+        sys.exit(0)
+
+    # Process commits
+    formatted_pr_commits = []
+    formatted_other_commits = []
+
+    for line in commits.split("\n"):
+        if not line:
+            continue
+        parts = line.split("|")
+        if len(parts) < 2:
+            continue
+        message = parts[0]
+        _author = parts[1]
+
+        # Extract PR number if present
+        pr_match = re.search(r"\(#(\d+)\)", message)
+        if pr_match:
+            pr_num = pr_match.group(1)
+            # Remove the (#num) part from message
+            clean_message = re.sub(r"\s*\(#\d+\)", "", message).strip()
+            formatted_line = f"{clean_message} in #{pr_num}"
+            formatted_pr_commits.append(formatted_line)
+        else:
+            formatted_line = f"{message}"
+            formatted_other_commits.append(formatted_line)
+
+    initial_message = f"Release {new_tag}\n\n"
+    if formatted_pr_commits:
+        initial_message += "Pull Requests:\n"
+        for line in formatted_pr_commits:
+            initial_message += f"- {line}\n"
+        initial_message += "\n"
+
+    if formatted_other_commits:
+        initial_message += "Other Changes:\n"
+        for line in formatted_other_commits:
+            initial_message += f"- {line}\n"
+
+    # Create temporary file for editing
+    with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
+        tmp.write(initial_message.encode("utf-8"))
+        tmp_path = tmp.name
+
+    editor = os.environ.get("EDITOR", "nano")
+    subprocess.call([editor, tmp_path])
+
+    with open(tmp_path, "r") as f:
+        tag_message = f.read().strip()
+
+    if not tag_message:
+        os.unlink(tmp_path)
+        print("Tag message is empty. Aborting.")
+        sys.exit(1)
+
+    print("\n--- Tag Message ---")
+    print(tag_message)
+    print("-------------------\n")
+
+    confirm = input(f"Create and push tag {new_tag}? (y/n): ")
+    if confirm.lower() == "y":
+        if dry_run:
+            print(f"[DRY-RUN] Would create annotated tag: {new_tag}")
+            print(f"[DRY-RUN] Would push tag {new_tag} to origin.")
+        else:
+            # Create annotated tag
+            run_command(f'git tag -a {new_tag} -F "{tmp_path}"')
+            print(f"Tag {new_tag} created locally.")
+
+            # Push tag
+            run_command(f"git push origin {new_tag}")
+            print(f"Tag {new_tag} pushed to origin.")
+    else:
+        print("Aborted.")
+
+    os.unlink(tmp_path)
+
+
+if __name__ == "__main__":
+    main()

{ucapi-0.5.2 → ucapi-0.7.0}/test-requirements.txt

@@ -3,7 +3,7 @@
 # Workaround: use a pre-commit hook with https://github.com/scikit-image/scikit-image/blob/main/tools/generate_requirements.py
 
 # pin pylint version: it has a tendendy for stricter rules in patch updates!
-pylint==4.0.4
+pylint==4.0.5
 flake8-docstrings
 flake8
 black

{ucapi-0.5.2 → ucapi-0.7.0}/tests/test_api.py

@@ -1,22 +1,22 @@
 import unittest
 from copy import deepcopy
 
-from ucapi.api import filter_log_msg_data
+from ucapi.api import sanitize_json_message
 from ucapi.media_player import Attributes
 
 
-class TestFilterLogMsgData(unittest.TestCase):
+class TestSanitizeJsonMessage(unittest.TestCase):
 
     def test_no_modification_when_no_msg_data(self):
         data = {}
-        result = filter_log_msg_data(data)
+        result = sanitize_json_message(data)
         self.assertEqual(result, {}, "The result should be an empty dictionary")
 
     def test_no_changes_when_media_image_url_not_present(self):
         data = {"msg_data": {"attributes": {"state": "playing", "volume": 50}}}
         original = deepcopy(data)
 
-        result = filter_log_msg_data(data)
+        result = sanitize_json_message(data)
 
         self.assertEqual(
             result,
@@ -36,9 +36,9 @@ class TestFilterLogMsgData(unittest.TestCase):
         expected_result = deepcopy(data)
         expected_result["msg_data"]["attributes"][
             Attributes.MEDIA_IMAGE_URL
-        ] = "data:***"
+        ] = "data:..."
 
-        result = filter_log_msg_data(data)
+        result = sanitize_json_message(data)
 
         self.assertEqual(
             result, expected_result, "The MEDIA_IMAGE_URL attribute should be filtered"
@@ -65,12 +65,12 @@ class TestFilterLogMsgData(unittest.TestCase):
         expected_result = deepcopy(data)
         expected_result["msg_data"][0]["attributes"][
             Attributes.MEDIA_IMAGE_URL
-        ] = "data:***"
+        ] = "data:..."
         expected_result["msg_data"][1]["attributes"][
             Attributes.MEDIA_IMAGE_URL
-        ] = "data:***"
+        ] = "data:..."
 
-        result = filter_log_msg_data(data)
+        result = sanitize_json_message(data)
 
         self.assertEqual(
             result,
@@ -88,8 +88,48 @@ class TestFilterLogMsgData(unittest.TestCase):
         }
         original_data = deepcopy(data)
 
-        filter_log_msg_data(data)
+        sanitize_json_message(data)
 
         self.assertEqual(
             data, original_data, "The input data should not be modified by the function"
         )
+
+    def test_generic_sensitive_keys_redaction(self):
+        sensitive_keys = [
+            "token",
+            "token_id",
+            "access_token",
+            "refresh_token",
+            "id_token",
+            "authorization_code",
+            "client_secret",
+            "secret",
+            "auth_url",
+            "client_data",
+            "password",
+        ]
+
+        for key in sensitive_keys:
+            msg = {key: "sensitive-value", "other": "public-value"}
+            sanitized = sanitize_json_message(msg)
+            self.assertEqual(
+                sanitized[key], "***REDACTED***", f"{key} should be redacted"
+            )
+            self.assertEqual(
+                sanitized["other"], "public-value", "public fields should remain intact"
+            )
+
+    def test_recursive_redaction(self):
+        msg = {
+            "level1": {
+                "token": "secret1",
+                "level2": {"secret": "secret2", "public": "data"},
+            },
+            "array": [{"refresh_token": "secret3"}, "plain-string"],
+        }
+        sanitized = sanitize_json_message(msg)
+        self.assertEqual(sanitized["level1"]["token"], "***REDACTED***")
+        self.assertEqual(sanitized["level1"]["level2"]["secret"], "***REDACTED***")
+        self.assertEqual(sanitized["level1"]["level2"]["public"], "data")
+        self.assertEqual(sanitized["array"][0]["refresh_token"], "***REDACTED***")
+        self.assertEqual(sanitized["array"][1], "plain-string")

ucapi-0.7.0/tests/test_media_player.py

@@ -0,0 +1,159 @@
+"""
+Tests for media player entity.
+"""
+
+import unittest
+from ucapi.media_player import SearchMediaFilter, MediaClass, BrowseMediaItem
+
+
+class TestMediaPlayer(unittest.TestCase):
+    """Media player tests."""
+
+    def test_search_media_filter_media_classes(self):
+        """Test SearchMediaFilter media_classes with standard and custom values."""
+        # Test with standard MediaClass
+        smf = SearchMediaFilter(media_classes=[MediaClass.ALBUM, MediaClass.TRACK])
+        self.assertEqual(smf.media_classes, [MediaClass.ALBUM, MediaClass.TRACK])
+
+        # Test with strings that match MediaClass
+        smf = SearchMediaFilter(media_classes=["album", "track"])
+        self.assertEqual(smf.media_classes, [MediaClass.ALBUM, MediaClass.TRACK])
+
+        # Test with custom string values
+        try:
+            smf = SearchMediaFilter(media_classes=["custom_class", "another_one"])
+            self.assertEqual(smf.media_classes, ["custom_class", "another_one"])
+        except ValueError as e:
+            self.fail(
+                f"SearchMediaFilter raised ValueError for custom media classes: {e}"
+            )
+
+    def test_search_media_filter_mixed_classes(self):
+        """Test SearchMediaFilter with a mix of MediaClass and custom strings."""
+        try:
+            smf = SearchMediaFilter(media_classes=[MediaClass.ALBUM, "custom_class"])
+            self.assertEqual(smf.media_classes, [MediaClass.ALBUM, "custom_class"])
+        except ValueError as e:
+            self.fail(
+                f"SearchMediaFilter raised ValueError for mixed media classes: {e}"
+            )
+
+    def test_search_media_filter_none(self):
+        """Test SearchMediaFilter with None media_classes."""
+        smf = SearchMediaFilter(media_classes=None)
+        self.assertIsNone(smf.media_classes)
+
+    def test_search_media_filter_from_dict(self):
+        """Test SearchMediaFilter.from_dict with custom values."""
+        data = {
+            "media_classes": ["album", "custom_class"],
+            "artist": "Some Artist",
+            "album": "Some Album",
+        }
+        try:
+            smf = SearchMediaFilter.from_dict(data)
+            self.assertEqual(smf.media_classes, [MediaClass.ALBUM, "custom_class"])
+            self.assertEqual(smf.artist, "Some Artist")
+            self.assertEqual(smf.album, "Some Album")
+        except ValueError as e:
+            self.fail(
+                f"SearchMediaFilter.from_dict raised ValueError for custom media classes: {e}"
+            )
+
+    def test_browse_media_item_validation_mandatory(self):
+        """Test BrowseMediaItem mandatory field validation."""
+        # Valid mandatory fields
+        item = BrowseMediaItem(media_id="id1", title="Title")
+        self.assertEqual(item.media_id, "id1")
+        self.assertEqual(item.title, "Title")
+
+        # media_id empty
+        with self.assertRaisesRegex(
+            ValueError, "media_id must be at least 1 characters"
+        ):
+            BrowseMediaItem(media_id="", title="Title")
+
+        # media_id too long
+        with self.assertRaisesRegex(
+            ValueError, "media_id must be at most 255 characters"
+        ):
+            BrowseMediaItem(media_id="a" * 256, title="Title")
+
+        # media_id wrong type
+        with self.assertRaisesRegex(TypeError, "media_id must be str, got int"):
+            BrowseMediaItem(media_id=123, title="Title")
+
+        # title empty
+        with self.assertRaisesRegex(ValueError, "title must be at least 1 characters"):
+            BrowseMediaItem(media_id="id1", title="")
+
+        # title too long
+        with self.assertRaisesRegex(ValueError, "title must be at most 255 characters"):
+            BrowseMediaItem(media_id="id1", title="a" * 256)
+
+    def test_browse_media_item_validation_optional(self):
+        """Test BrowseMediaItem optional field validation."""
+        # subtitle
+        with self.assertRaisesRegex(
+            ValueError, "subtitle must be at least 1 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", subtitle="")
+        with self.assertRaisesRegex(
+            ValueError, "subtitle must be at most 255 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", subtitle="a" * 256)
+
+        # artist
+        with self.assertRaisesRegex(ValueError, "artist must be at least 1 characters"):
+            BrowseMediaItem(media_id="id1", title="Title", artist="")
+        with self.assertRaisesRegex(
+            ValueError, "artist must be at most 255 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", artist="a" * 256)
+
+        # album
+        with self.assertRaisesRegex(ValueError, "album must be at least 1 characters"):
+            BrowseMediaItem(media_id="id1", title="Title", album="")
+        with self.assertRaisesRegex(ValueError, "album must be at most 255 characters"):
+            BrowseMediaItem(media_id="id1", title="Title", album="a" * 256)
+
+        # media_class (only when it's a string)
+        # Note: media class is allowed to be empty!
+        BrowseMediaItem(media_id="id1", title="Title", media_class="")
+
+        with self.assertRaisesRegex(
+            ValueError, "media_class must be at most 255 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", media_class="a" * 256)
+        # Verify it accepts MediaClass enum without error
+        BrowseMediaItem(media_id="id1", title="Title", media_class=MediaClass.ALBUM)
+
+        # media_type (only when it's a string)
+        # Note: media type is allowed to be empty!
+        BrowseMediaItem(media_id="id1", title="Title", media_type="")
+
+        with self.assertRaisesRegex(
+            ValueError, "media_type must be at most 255 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", media_type="a" * 256)
+
+    def test_browse_media_item_validation_thumbnail(self):
+        """Test BrowseMediaItem thumbnail field validation."""
+        # Valid length
+        BrowseMediaItem(media_id="id1", title="Title", thumbnail="a" * 32768)
+
+        # Too short (empty)
+        with self.assertRaisesRegex(
+            ValueError, "thumbnail must be at least 1 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", thumbnail="")
+
+        # Too long
+        with self.assertRaisesRegex(
+            ValueError, "thumbnail must be at most 32768 characters"
+        ):
+            BrowseMediaItem(media_id="id1", title="Title", thumbnail="a" * 32769)
+
+
+if __name__ == "__main__":
+    unittest.main()

ucapi-0.7.0/tests/test_paging.py

@@ -0,0 +1,131 @@
+"""Unit tests for Paging and Pagination classes."""
+
+import json
+import unittest
+from dataclasses import asdict
+
+from ucapi.api_definitions import Pagination, Paging
+
+
+class TestPaging(unittest.TestCase):
+    """Test cases for the Paging class."""
+
+    def test_paging_default(self):
+        """Test default Paging instantiation."""
+        paging = Paging()
+        self.assertEqual(paging.page, 1)
+        self.assertEqual(paging.limit, 10)
+        self.assertEqual(paging.offset, 0)
+
+    def test_paging_custom(self):
+        """Test custom Paging instantiation."""
+        paging = Paging(page=2, limit=20)
+        self.assertEqual(paging.page, 2)
+        self.assertEqual(paging.limit, 20)
+        self.assertEqual(paging.offset, 20)
+
+    def test_paging_invalid_page(self):
+        """Test validation for invalid page number."""
+        with self.assertRaises(ValueError) as cm:
+            Paging(page=0)
+        self.assertIn("Invalid page: 0", str(cm.exception))
+
+        with self.assertRaises(ValueError):
+            Paging(page=-1)
+
+    def test_paging_invalid_limit(self):
+        """Test validation for invalid limit."""
+        with self.assertRaises(ValueError) as cm:
+            Paging(limit=0)
+        self.assertIn("Invalid limit: 0", str(cm.exception))
+
+        with self.assertRaises(ValueError):
+            Paging(limit=-1)
+        with self.assertRaises(ValueError):
+            Paging(limit=10000)
+
+    def test_paging_from_dict(self):
+        """Test constructing Paging from a dictionary."""
+        data = {"page": 3, "limit": 50}
+        paging = Paging.from_dict(data)
+        self.assertEqual(paging.page, 3)
+        self.assertEqual(paging.limit, 50)
+
+    def test_paging_from_dict_defaults(self):
+        """Test constructing Paging from an empty dictionary using defaults."""
+        paging = Paging.from_dict({})
+        self.assertEqual(paging.page, 1)
+        self.assertEqual(paging.limit, 10)
+
+    def test_paging_serialization(self):
+        """Test Paging JSON serialization."""
+        paging = Paging(page=2, limit=25)
+        serialized = asdict(paging)
+        self.assertEqual(serialized, {"page": 2, "limit": 25})
+
+        # Verify JSON round-trip
+        json_str = json.dumps(serialized)
+        self.assertEqual(json.loads(json_str), {"page": 2, "limit": 25})
+
+
+class TestPagination(unittest.TestCase):
+    """Test cases for the Pagination class."""
+
+    def test_pagination_instantiation(self):
+        """Test Pagination instantiation with all fields."""
+        pagination = Pagination(page=1, limit=10, count=100)
+        self.assertEqual(pagination.page, 1)
+        self.assertEqual(pagination.limit, 10)
+        self.assertEqual(pagination.count, 100)
+
+    def test_pagination_no_count(self):
+        """Test Pagination instantiation without count."""
+        pagination = Pagination(page=2, limit=20)
+        self.assertEqual(pagination.page, 2)
+        self.assertEqual(pagination.limit, 20)
+        self.assertIsNone(pagination.count)
+
+    def test_pagination_invalid_page(self):
+        """Test validation for invalid page number."""
+        with self.assertRaises(ValueError) as cm:
+            Pagination(page=0, limit=10)
+        self.assertIn("page must be >= 1", str(cm.exception))
+
+    def test_pagination_invalid_limit(self):
+        """Test validation for invalid limit."""
+        with self.assertRaises(ValueError) as cm:
+            Pagination(page=1, limit=-1)
+        self.assertIn("Invalid limit", str(cm.exception))
+
+    def test_pagination_limit_out_of_range(self):
+        """Test validation for invalid limit."""
+        with self.assertRaises(ValueError) as cm:
+            Pagination(page=1, limit=10000)
+        self.assertIn("Invalid limit", str(cm.exception))
+
+    def test_pagination_invalid_count(self):
+        """Test validation for invalid count."""
+        with self.assertRaises(ValueError) as cm:
+            Pagination(page=1, limit=10, count=-1)
+        self.assertIn("count cannot be negative", str(cm.exception))
+
+    def test_pagination_serialization(self):
+        """Test Pagination JSON serialization."""
+        pagination = Pagination(page=1, limit=10, count=100)
+        serialized = asdict(pagination)
+        self.assertEqual(serialized, {"page": 1, "limit": 10, "count": 100})
+
+    def test_pagination_serialization_no_count(self):
+        """Test Pagination JSON serialization when count is None."""
+        pagination = Pagination(page=2, limit=20)
+        json_data = asdict(pagination)
+
+        # Note: In JS/TS, undefined keys are omitted during JSON.stringify.
+        # In Python, None becomes `null` in JSON.
+        # This is not an issue: the Remote core service treats `null` as "not existing".
+        self.assertIn("count", json_data)
+        self.assertIsNone(json_data["count"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{ucapi-0.5.2 → ucapi-0.7.0}/ucapi/__init__.py

@@ -19,6 +19,8 @@ from .api_definitions import (  # isort:skip # noqa: F401
     DriverSetupRequest,
     Events,
     IntegrationSetupError,
+    Paging,
+    Pagination,
     RequestUserConfirmation,
     RequestUserInput,
     SetupAction,
@@ -42,7 +44,20 @@ from .button import Button  # noqa: F401
 from .climate import Climate  # noqa: F401
 from .cover import Cover  # noqa: F401
 from .light import Light  # noqa: F401
-from .media_player import MediaPlayer  # noqa: F401
+from .media_player import (  # noqa: F401
+    BrowseMediaItem,
+    BrowseOptions,
+    BrowseResults,
+    MediaClass,
+    MediaContentType,
+    MediaPlayAction,
+    MediaPlayer,
+    RepeatMode,
+    SearchMediaFilter,
+    SearchMediaItem,
+    SearchOptions,
+    SearchResults,
+)
 from .remote import Remote  # noqa: F401
 from .select import Select  # noqa: F401
 from .sensor import Sensor  # noqa: F401

ucapi-0.7.0/ucapi/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)
+
+__commit_id__ = commit_id = 'gf6e6e4a0e'