PyDLNA 0.1.4__py3-none-any.whl

pydlna/services.py

@@ -0,0 +1,126 @@
+"""UPnP service implementations exposed by the media server.
+
+Each service owns a set of SOAP actions. The HTTP layer (handlers.py) parses
+the envelope and calls ``handle()``; the service does the actual work and
+returns the response fields. This keeps protocol parsing and business logic
+in separate, testable places.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Callable, Mapping
+
+from pydlna.errors import UPnPError
+from pydlna.formatters import XMLFormatter
+
+if TYPE_CHECKING:
+    from pydlna.server import MediaLibrary
+
+logger = logging.getLogger(__name__)
+
+
+class UPnPService:
+    """Base class: dispatches SOAP action names to Python callables."""
+
+    service_type = ""
+
+    def __init__(self) -> None:
+        self._actions: dict[str, Callable] = {}
+
+    def handle(self, action: str, args: Mapping[str, str], base_url: str) -> dict[str, str]:
+        method = self._actions.get(action)
+        if method is None:
+            raise UPnPError(401, f"Invalid action: {action}")
+        logger.debug("%s.%s(%s)", type(self).__name__, action, dict(args))
+        return method(args, base_url)
+
+
+class ContentDirectoryService(UPnPService):
+    """Implements ``ContentDirectory:1`` over a flat media library."""
+
+    service_type = "urn:schemas-upnp-org:service:ContentDirectory:1"
+
+    def __init__(self, library: "MediaLibrary", root_title: str = "PyDLNA") -> None:
+        super().__init__()
+        self.library = library
+        self.root_title = root_title
+        self._actions = {
+            "Browse": self._browse,
+            "Search": self._search,
+            "GetSearchCapabilities": lambda args, base_url: {"SearchCaps": ""},
+            "GetSortCapabilities": lambda args, base_url: {"SortCaps": ""},
+            "GetSystemUpdateID": lambda args, base_url: {"Id": "1"},
+        }
+
+    def _browse(self, args: Mapping[str, str], base_url: str) -> dict[str, str]:
+        object_id = args.get("ObjectID", "0")
+        browse_flag = args.get("BrowseFlag", "BrowseDirectChildren")
+        start = _to_int(args.get("StartingIndex"), 0)
+        count = _to_int(args.get("RequestedCount"), 0)
+
+        if browse_flag == "BrowseMetadata":
+            didl, returned, total = self._metadata(object_id, base_url)
+        elif object_id == "0":
+            files = self.library.files
+            selection = files[start:] if count == 0 else files[start:start + count]
+            didl = XMLFormatter.didl_items(selection, base_url)
+            returned, total = len(selection), len(files)
+        else:
+            # The library is flat: only the root container has children.
+            raise UPnPError(701, f"No such object: {object_id}")
+        return {
+            "Result": didl,
+            "NumberReturned": str(returned),
+            "TotalMatches": str(total),
+            "UpdateID": "1",
+        }
+
+    def _metadata(self, object_id: str, base_url: str) -> tuple[str, int, int]:
+        if object_id == "0":
+            didl = XMLFormatter.didl_root_container(self.root_title, len(self.library))
+            return didl, 1, 1
+        media = self.library.get(object_id)
+        if media is None:
+            raise UPnPError(701, f"No such object: {object_id}")
+        return XMLFormatter.didl_items([media], base_url), 1, 1
+
+    def _search(self, args: Mapping[str, str], base_url: str) -> dict[str, str]:
+        # Searching is out of scope for a flat library; answer with an empty
+        # (but valid) result instead of an error so renderers don't choke.
+        return {
+            "Result": XMLFormatter.didl_items([], base_url),
+            "NumberReturned": "0",
+            "TotalMatches": "0",
+            "UpdateID": "1",
+        }
+
+
+class ConnectionManagerService(UPnPService):
+    """Implements ``ConnectionManager:1`` for HTTP-pull streaming."""
+
+    service_type = "urn:schemas-upnp-org:service:ConnectionManager:1"
+
+    def __init__(self, library: "MediaLibrary") -> None:
+        super().__init__()
+        self.library = library
+        self._actions = {
+            "GetProtocolInfo": self._protocol_info,
+            "GetCurrentConnectionIDs": lambda args, base_url: {"ConnectionIDs": ""},
+            "GetCurrentConnectionInfo": self._connection_info,
+        }
+
+    def _protocol_info(self, args: Mapping[str, str], base_url: str) -> dict[str, str]:
+        mime_types = sorted({media.mime_type for media in self.library if media.mime_type})
+        source = ";".join(f"http-get:*:{mime}:*" for mime in mime_types)
+        return {"Source": source, "Sink": ""}
+
+    def _connection_info(self, args: Mapping[str, str], base_url: str) -> dict[str, str]:
+        raise UPnPError(701, "Invalid connection ID")
+
+
+def _to_int(value: object, default: int) -> int:
+    try:
+        return int(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return default

pydlna-0.1.4.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: PyDLNA
+Version: 0.1.4
+Summary: A simple, zero-dependency DLNA Python library for discovery, streaming, and device control.
+Author: SurrealisticRabbit
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# PyDLNA
+
+A simple, zero-dependency Python library for DLNA streaming, discovery, and device control.
+
+Most DLNA libraries out there are either overly complex, poorly documented, or unmaintained. **PyDLNA** is built to be fit-for-purpose, straightforward, and ready to use in a few lines of code.
+
+```bash
+pip install PyDLNA
+
+```
+
+---
+
+## Quick Concepts
+
+* **`DLNADiscovery()`** — Your best friend for finding DLNA devices (renderers, media servers, etc.) on your local network.
+* **`DLNAServer()`** — Hosts and serves your local media files over HTTP with proper DLNA headers.
+* **`device.controller()`** — Gives you an active playback control session (`.play()`, `.pause()`, track info) for a specific renderer.
+
+---
+
+## Usage Examples
+
+### 1. Basic Streaming — `examples/basic.py`
+
+Serve a directory, find a smart TV or speaker on the network, and throw a video/audio track directly to it:
+
+```python
+import time
+from pydlna import DLNADiscovery, DLNAServer
+
+folder = "D:/Movies"
+
+with DLNAServer(name="PyDLNA Example") as server:
+    server.library.add_directory(folder)
+
+    target = None
+    with DLNADiscovery().discover() as devices:
+        for device in devices:
+            if device.is_renderer:
+                print(f"Found renderer: {device.name}")
+                target = device
+                break
+
+    if target is None:
+        print("No renderer found.")
+    else:
+        with target.controller() as session:
+            media = server.library[0]
+            print(f"Sending: {media.url_for(target.address)}")
+            session.play(media)
+
+            while session.is_playing():
+                current = session.currently_playing
+                print(f"Playing: {media.title[:18]} > {current.position}:{current.duration}", end="\r")
+                time.sleep(1)
+
+```
+
+---
+
+### 2. Inspecting Network Devices — `examples/client_info.py`
+
+Scan your network and inspect the hardware, model numbers, and supported playback formats of discovered renderers:
+
+```python
+from pydlna import DLNADiscovery
+
+for client in DLNADiscovery().discover():
+    if client.is_renderer:
+        print(f"{client.name or '(unnamed)'}  @  {client.address}")
+        print(f"  Manufacturer       : {client.manufacturer} ({client.manufacturer_url})")
+        print(f"  Model              : {client.model_name} {client.model_number}")
+        print(f"  Playable formats   : {client.playback_formats}")
+        print(f"  Supported protocols: {client.supported_protocols}")
+        print("-" * 50)
+
+```

pydlna-0.1.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+pydlna/__init__.py,sha256=oHQR8EN_Ok3VTp2erwfjSUQHOxCb_mN45AnUHfgC0jQ,650
+pydlna/_version.py,sha256=dCmqTphVTtnLNv5-BupgeR8iw0z5iLBjWjRFRXqOyso,520
+pydlna/client.py,sha256=Vb-rYfy2UYpDv5iYSFHEhTj1J6YEk_mIhhzAb1urBU4,12051
+pydlna/discovery.py,sha256=NTIPcZK2SUCeknuBPGsNi2cshxbmReyN-yZviNuhB5I,7084
+pydlna/errors.py,sha256=BKMG-Cyx4vs5uBw2SwWX09WoByVTsN5Yd4Kdv8cUE6Y,483
+pydlna/file.py,sha256=I4erClK_LgWEfXicim8dtMjeAqvrVr3ItOJ7xdjwTV8,3182
+pydlna/formatters.py,sha256=Xna6rD4NwIHuUXHOPPB-WRMfBiEwzLJITvn4VJ9az0w,13563
+pydlna/handlers.py,sha256=jWp8dlnylYy4KTcAzY-8XR5TqLIKjuuyTu8OdQa5zXo,6813
+pydlna/server.py,sha256=IwWToQWBMr2l4zzJ0BxLGOu4xTg9oN9Md6VOW_nFUvY,5916
+pydlna/services.py,sha256=MmuzWGnwqfAH93eE_FdrJcwLZeYWSr0CEBDDkRwschU,4865
+pydlna-0.1.4.dist-info/licenses/LICENSE.md,sha256=KmK9PMRvBFTlsTb2osIH71l-c0fhVNi3BHH40-5S28Y,1074
+pydlna-0.1.4.dist-info/METADATA,sha256=4VoaysDtndD36HucZh_QqcLP__V_LKeA5rqVNFMbtCI,2962
+pydlna-0.1.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pydlna-0.1.4.dist-info/top_level.txt,sha256=YZmueIFNHkmoxU4pZYjW-fzJioyt30lttuG6-_rGC8s,7
+pydlna-0.1.4.dist-info/RECORD,,

pydlna-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pydlna-0.1.4.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SurrealisticRabbit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydlna-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pydlna