codeSamples.yaml

overlay: 1.0.0
info:
  title: CodeSamples overlay for python target
  version: 0.0.0
actions:
  - target: $["paths"]["/"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_server_info(request={})

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/:/eventsource/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.events.get_notifications(request={})

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/:/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.preferences.get_all_preferences()

                assert res.media_container_with_settings is not None

                # Handle response
                print(res.media_container_with_settings)
  - target: $["paths"]["/:/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.preferences.set_preferences(request={
                    "prefs": {},
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/:/prefs/get"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.preferences.get_preference(request={})

                assert res.media_container_with_settings is not None

                # Handle response
                print(res.media_container_with_settings)
  - target: $["paths"]["/:/progress"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.get_progress(request={
                    "key": "<key>",
                    "time": 181086,
                })

                assert res.progress_response is not None

                # Handle response
                print(res.progress_response)
  - target: $["paths"]["/:/rate"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.rate.set_rating(request={
                    "identifier": "<value>",
                    "key": "<key>",
                    "rating": 8722.46,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/:/scrobble"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.timeline.mark_played(request={
                    "identifier": "<value>",
                    "key": "59398",
                    "uri": "https://mad-dredger.name",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/:/timeline"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.timeline.report(request=operations.ReportRequest(
                    key="/foo",
                    rating_key="xyz",
                    state=operations.State.PLAYING,
                    play_queue_item_id="123",
                    time=0,
                    duration=10000,
                    continuing=components.BoolInt.TRUE,
                    updated=14200000,
                    offline=components.BoolInt.TRUE,
                    time_to_first_frame=1000,
                    time_stalled=1000,
                    bandwidth=100,
                    buffered_time=100,
                    buffered_size=1024,
                ))

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/:/unscrobble"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.timeline.unscrobble(request={
                    "identifier": "<value>",
                    "uri": "https://qualified-order.org",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/:/websocket/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.events.connect_web_socket(request={})

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/:/websockets/notifications"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.events.get_websocket_notifications(request={})

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/accounts"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_system_accounts(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/actions/addToWatchlist"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.add_to_watchlist(request={
                    "uri": "https://frightened-duster.com/",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/actions/removeFromContinueWatching"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.remove_from_continue_watching(request={
                    "key": "<key>",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/actions/removeFromWatchlist"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.remove_from_watchlist(request={
                    "uri": "https://miserable-scrap.net",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/activities"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.activities.list_activities()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/activities/{activityId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.activities.cancel_activity(request={
                    "activity_id": "d6199ba1-fb5e-4cae-bf17-1a5369c1cf1e",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/api/invites/requests/{inviteId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.accept_invite(request=operations.AcceptInviteRequest(
                    invite_id=530502,
                    friend=components.BoolInt.TRUE,
                    home=components.BoolInt.TRUE,
                    server=components.BoolInt.TRUE,
                ))

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/api/resources"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_legacy_resources()

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/api/users/"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_legacy_users()

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/api/v2/user/webhooks"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_user_webhooks()

                assert res.webhook_payload is not None

                # Handle response
                print(res.webhook_payload)
  - target: $["paths"]["/api/v2/user/webhooks"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.add_user_webhook(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/auth/jwk"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.register_device_jwk(request={
                    "jwk_registration_request": {
                        "jwk": {
                            "crv": "string value",
                            "kid": "string value",
                            "kty": "string value",
                            "x": "string value",
                        },
                    },
                })

                assert res.auth_token_response is not None

                # Handle response
                print(res.auth_token_response)
  - target: $["paths"]["/auth/keys"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_auth_keys(request={})

                assert res.auth_keys_response is not None

                # Handle response
                print(res.auth_keys_response)
  - target: $["paths"]["/auth/nonce"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_auth_nonce(request={})

                assert res.auth_nonce_response is not None

                # Handle response
                print(res.auth_nonce_response)
  - target: $["paths"]["/auth/token"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.exchange_jwt_token(request={
                    "token_exchange_request": {
                        "client_identifier": "string value",
                        "jwt": "string value",
                        "scope": "string value",
                    },
                })

                assert res.auth_token_response is not None

                # Handle response
                print(res.auth_token_response)
  - target: $["paths"]["/butler"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.butler.stop_tasks()

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/butler"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.butler.get_tasks()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/butler"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.butler.start_tasks()

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/butler/{butlerTask}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.butler.stop_task(request={
                    "butler_task": operations.ButlerTask.CLEAN_OLD_BUNDLES,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/butler/{butlerTask}"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.butler.start_task(request={
                    "butler_task": operations.PathParamButlerTask.REFRESH_LOCAL_MEDIA,
                })

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/claim/token.json"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_claim_token(request={})

                assert res.claim_token_response is not None

                # Handle response
                print(res.claim_token_response)
  - target: $["paths"]["/clients"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_clients(request={})

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/cloud_server"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_cloud_server(request={})

                assert res.cloud_server_response is not None

                # Handle response
                print(res.cloud_server_response)
  - target: $["paths"]["/devices"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_system_devices(request={})

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/diagnostics"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_diagnostics(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/diagnostics/databases"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.download_database_diagnostics(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/diagnostics/logs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.download_log_bundle(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/downloadQueue"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.create_download_queue()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/downloadQueue/{queueId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.get_download_queue(request={
                    "queue_id": 922802,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/downloadQueue/{queueId}/add"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.add_download_queue_items(request=operations.AddDownloadQueueItemsRequest(
                    advanced_subtitles=components.AdvancedSubtitles.BURN,
                    audio_boost=50,
                    audio_channel_count=5,
                    auto_adjust_quality=components.BoolInt.TRUE,
                    auto_adjust_subtitle=components.BoolInt.TRUE,
                    direct_play=components.BoolInt.TRUE,
                    direct_stream=components.BoolInt.TRUE,
                    direct_stream_audio=components.BoolInt.TRUE,
                    disable_resolution_rotation=components.BoolInt.TRUE,
                    has_mde=components.BoolInt.TRUE,
                    location=components.Location.WAN,
                    media_buffer_size=102400,
                    media_index=0,
                    music_bitrate=5000,
                    offset=90.5,
                    part_index=0,
                    path="/library/metadata/151671",
                    peak_bitrate=12000,
                    photo_resolution="1080x1080",
                    protocol=components.Protocol.DASH,
                    seconds_per_segment=5,
                    subtitle_size=50,
                    subtitles=components.Subtitles.BURN,
                    video_bitrate=12000,
                    video_quality=50,
                    video_resolution="1080x1080",
                    queue_id=984925,
                    keys=[
                        "/library/metadata/3",
                        "/library/metadata/6",
                    ],
                ))

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/decision"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.get_item_decision(request={
                    "queue_id": 231605,
                    "item_id": 32,
                })

                assert res.media_container_with_decision is not None

                # Handle response
                print(res.media_container_with_decision)
  - target: $["paths"]["/downloadQueue/{queueId}/item/{itemId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.get_download_queue_media(request={
                    "queue_id": 663184,
                    "item_id": 32,
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/downloadQueue/{queueId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.list_download_queue_items(request={
                    "queue_id": 524138,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.remove_download_queue_items(request={
                    "queue_id": 946275,
                    "item_id": [
                        32,
                        345,
                        23,
                    ],
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.get_download_queue_items(request={
                    "queue_id": 809886,
                    "item_id": [
                        32,
                        345,
                        23,
                    ],
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/downloadQueue/{queueId}/items/{itemId}/restart"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.download_queue.restart_processing_download_queue_items(request={
                    "queue_id": 713001,
                    "item_id": [
                        32,
                        345,
                        23,
                    ],
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/downloads/{channel}.json"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_plex_downloads(request={
                    "channel": "<value>",
                })

                assert res.plex_downloads_response is not None

                # Handle response
                print(res.plex_downloads_response)
  - target: $["paths"]["/features"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_features()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/friends"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_friends(request={})

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/geoip"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_geo_ip(request={})

                assert res.geo_ip_response is not None

                # Handle response
                print(res.geo_ip_response)
  - target: $["paths"]["/home"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_home()

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/home/users"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_home_users(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/home/users"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.create_home_user(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/home/users/restricted/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.update_restricted_user(request={
                    "user_id": 130660,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/home/users/{id}/switch"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.switch_home_user(request={
                    "id": 135337,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/home/users/{userId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.delete_home_user(request={
                    "user_id": 768153,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/home/users/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.update_home_user(request={
                    "user_id": 187897,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_all_hubs(request={
                    "only_transient": components.BoolInt.TRUE,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/continueWatching"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_continue_watching(request={})

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/continueWatching/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_continue_watching_items(request={})

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/hubs/home/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_home_recently_added(request={})

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_hub_items(request={
                    "identifier": [
                        "<value 1>",
                        "<value 2>",
                        "<value 3>",
                    ],
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/hubs/metadata/{metadataId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_metadata_hubs(request={
                    "metadata_id": 605482,
                    "only_transient": components.BoolInt.TRUE,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/metadata/{metadataId}/postplay"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_postplay_hubs(request={
                    "metadata_id": 441419,
                    "only_transient": components.BoolInt.TRUE,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/metadata/{metadataId}/related"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_related_hubs(request={
                    "metadata_id": 8858,
                    "only_transient": components.BoolInt.TRUE,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/promoted"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_promoted_hubs(request={})

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/search"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.search.search_hubs(request={
                    "query": "<value>",
                    "section_id": 1,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/search/voice"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.search.voice_search_hubs(request={
                    "type": components.MediaType.TV_SHOW,
                    "query": "<value>",
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.get_section_hubs(request={
                    "section_id": 336924,
                    "only_transient": components.BoolInt.TRUE,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.reset_section_defaults(request={
                    "section_id": 383022,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.list_hubs(request={
                    "section_id": 442546,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.create_custom_hub(request=operations.CreateCustomHubRequest(
                    section_id=869922,
                    metadata_item_id=703843,
                    promoted_to_recommended=components.BoolInt.TRUE,
                    promoted_to_own_home=components.BoolInt.TRUE,
                    promoted_to_shared_home=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.move_hub(request={
                    "section_id": 755710,
                    "identifier": "<value>",
                })

                assert res.get_responses_200 is not None

                # Handle response
                print(res.get_responses_200)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.delete_custom_hub(request={
                    "section_id": 625677,
                    "identifier": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/hubs/sections/{sectionId}/manage/{identifier}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.hubs.update_hub_visibility(request=operations.UpdateHubVisibilityRequest(
                    section_id=341650,
                    identifier="<value>",
                    promoted_to_recommended=components.BoolInt.TRUE,
                    promoted_to_own_home=components.BoolInt.TRUE,
                    promoted_to_shared_home=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/identity"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI() as plex_api:

                res = plex_api.general.get_identity()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/ip"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_ip(request={})

                assert res.ip_response is not None

                # Handle response
                print(res.ip_response)
  - target: $["paths"]["/library"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_root_library()

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/library/all"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_library_items(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/caches"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_caches()

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/clean/bundles"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.clean_bundles()

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/collections"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.collections.create_collection(request={
                    "type": components.MediaType.TV_SHOW,
                    "section_id": "<id>",
                })

                assert res.collection is not None

                # Handle response
                print(res.collection)
  - target: $["paths"]["/library/collections/{collectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_collection_image(request={
                    "collection_id": 474227,
                    "updated_at": 759379,
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/library/collections/{collectionId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_collection_items(request={
                    "collection_id": 314585,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/collections/{collectionId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_collections.add_collection_items(request={
                    "collection_id": 338144,
                    "uri": "https://expensive-bakeware.com",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_collections.update_collection_item(request={
                    "collection_id": 640014,
                    "item_id": 2136,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/collections/{collectionId}/items/{itemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_collections.move_collection_item(request={
                    "collection_id": 239532,
                    "item_id": 513864,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/file"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.ingest_transient_item(request=operations.IngestTransientItemRequest(
                    url="file:///storage%2Femulated%2F0%2FArcher-S01E01.mkv",
                    virtual_file_path="/Avatar.mkv",
                    compute_hashes=components.BoolInt.TRUE,
                    ingest_non_matches=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/matches"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_library_matches(request=operations.GetLibraryMatchesRequest(
                    type=components.MediaType.TV_SHOW,
                    include_full_metadata=components.BoolInt.TRUE,
                    include_ancestor_metadata=components.BoolInt.TRUE,
                    include_alternate_metadata_sources=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/media/{mediaId}/chapterImages/{chapter}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_chapter_image(request={
                    "media_id": 892563,
                    "chapter": 48348,
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/library/metadata/augmentations/{augmentationId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_augmentation_status(request={
                    "augmentation_id": "<id>",
                    "wait": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_metadata_item(request={
                    "ids": "<value>",
                    "proxy": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_metadata_item(request=operations.GetMetadataItemRequest(
                    ids=[],
                    async_check_files=components.BoolInt.TRUE,
                    async_refresh_local_media_agent=components.BoolInt.TRUE,
                    async_refresh_analysis=components.BoolInt.TRUE,
                    check_files=components.BoolInt.TRUE,
                    skip_refresh=components.BoolInt.TRUE,
                    check_file_availability=components.BoolInt.TRUE,
                    async_augment_metadata=components.BoolInt.TRUE,
                    augment_count=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{ids}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.edit_metadata_item(request={
                    "ids": [
                        "<value 1>",
                        "<value 2>",
                    ],
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/addetect"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.detect_ads(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_all_item_leaves(request={
                    "ids": "<value>",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{ids}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.analyze_metadata(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/chapterThumbs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.generate_thumbs(request={
                    "ids": "<value>",
                    "force": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/credits"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.detect_credits(request=operations.DetectCreditsRequest(
                    ids="<value>",
                    force=components.BoolInt.TRUE,
                    manual=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/extras"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_extras(request={
                    "ids": "<value>",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{ids}/extras"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.add_extras(request={
                    "ids": "<value>",
                    "url": "https://super-mortise.biz/",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/file"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_file(request={
                    "ids": "<value>",
                })

                assert res.two_hundred_audio_mpeg3_response_stream is not None

                # Handle response
                print(res.two_hundred_audio_mpeg3_response_stream)
  - target: $["paths"]["/library/metadata/{ids}/index"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.start_bif_generation(request={
                    "ids": "<value>",
                    "force": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/intro"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.detect_intros(request={
                    "ids": "<value>",
                    "force": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/marker"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.create_marker(request={
                    "ids": "<value>",
                    "media_type": 248391,
                    "start_time_offset": 535191,
                    "attributes": {},
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_marker(request={
                    "ids": "<value>",
                    "marker": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/marker/{marker}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.edit_marker(request={
                    "ids": "<value>",
                    "marker": "<value>",
                    "media_type": 884347,
                    "start_time_offset": 517251,
                    "attributes": {},
                })

                assert res.post_responses_200 is not None

                # Handle response
                print(res.post_responses_200)
  - target: $["paths"]["/library/metadata/{ids}/match"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.match_item(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/matches"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.list_matches(request={
                    "ids": "<value>",
                    "manual": components.BoolInt.TRUE,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{ids}/media/{mediaItem}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_media_item(request={
                    "ids": "<value>",
                    "media_item": "<value>",
                    "proxy": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/merge"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.merge_items(request={
                    "ids_path_parameter": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.set_item_preferences(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/refresh"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.refresh_items_metadata(request=operations.RefreshItemsMetadataRequest(
                    ids="<value>",
                    mark_updated=components.BoolInt.TRUE,
                    skip_refresh=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/related"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_related_items(request={
                    "ids": "<value>",
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/library/metadata/{ids}/similar"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.list_similar(request={
                    "ids": "<value>",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{ids}/split"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.split_item(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_subtitles(request=operations.GetSubtitlesRequest(
                    ids="<value>",
                    forced=components.BoolInt.TRUE,
                    hearing_impaired=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/tree"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_item_tree(request={
                    "ids": "<value>",
                })

                assert res.media_container_with_nested_metadata is not None

                # Handle response
                print(res.media_container_with_nested_metadata)
  - target: $["paths"]["/library/metadata/{ids}/unmatch"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.unmatch(request={
                    "ids": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/users/top"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.list_top_users(request={
                    "ids": "<value>",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/metadata/{ids}/voiceActivity"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.detect_voice_activity(request=operations.DetectVoiceActivityRequest(
                    ids="<value>",
                    force=components.BoolInt.TRUE,
                    manual=components.BoolInt.TRUE,
                ))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.set_item_artwork(request={
                    "ids": "<value>",
                    "element": operations.Element.BANNER,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/{element}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.update_item_artwork(request={
                    "ids": "<value>",
                    "element": operations.PathParamElement.CLEAR_LOGO,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/metadata/{ids}/{element}/{timestamp}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_item_artwork(request={
                    "ids": "<value>",
                    "element": operations.GetItemArtworkPathParamElement.POSTER,
                    "timestamp": 999555,
                })

                assert res.two_hundred_audio_mpeg3_response_stream is not None

                # Handle response
                print(res.two_hundred_audio_mpeg3_response_stream)
  - target: $["paths"]["/library/metadata/{id}/arts"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.upload_art(request={
                    "id": 996758,
                    "request_body": {
                        "file": {
                            "file_name": "example.file",
                            "content": open("example.file", "rb"),
                        },
                    },
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/metadata/{id}/children"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_children(request={
                    "id": 240367,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/computePath"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.compute_sonic_path(request={
                    "id": 622554,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/grandchildren"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_grandchildren(request={
                    "id": 679910,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/grandparent"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_grandparent(request={
                    "id": 191152,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_nearest_metadata(request={
                    "id": 62697,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/onDeck"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_on_deck(request={
                    "id": 883975,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/parent"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_parent(request={
                    "id": 352555,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/metadata/{id}/posters"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.upload_poster(request={
                    "id": 316927,
                    "request_body": {
                        "file": {
                            "file_name": "example.file",
                            "content": open("example.file", "rb"),
                        },
                    },
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/metadata/{id}/reviews"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_metadata_reviews(request={
                    "id": 146091,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/optimize"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.optimize_library(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/optimize"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.optimize_library_post(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/optimize"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.optimize_database(request={
                    "async_": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/parts/{partId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.set_stream_selection(request={
                    "part_id": 360489,
                    "all_parts": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_part_index(request={
                    "part_id": 724750,
                    "index": operations.Index.SD,
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/library/parts/{partId}/indexes/{index}/{offset}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_image_from_bif(request={
                    "part_id": 304273,
                    "index": operations.PathParamIndex.SD,
                    "offset": 939569,
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/library/parts/{partId}/{changestamp}/{filename}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_media_part(request={
                    "part_id": 877105,
                    "changestamp": 970622,
                    "filename": "example.file",
                    "download": components.BoolInt.TRUE,
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/library/people/{personId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_person(request={
                    "person_id": "<id>",
                })

                assert res.media_container_with_tags is not None

                # Handle response
                print(res.media_container_with_tags)
  - target: $["paths"]["/library/people/{personId}/media"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.list_person_media(request={
                    "person_id": "<id>",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/randomArtwork"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_random_artwork(request={
                    "sections": [
                        5,
                        6,
                    ],
                })

                assert res.media_container_with_artwork is not None

                # Handle response
                print(res.media_container_with_artwork)
  - target: $["paths"]["/library/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_recently_added_global(request={})

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/search"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.search_discover(request={
                    "search_types": "movies,tv",
                    "search_providers": "discover,PLEXAVOD,PLEXTVOD",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_library_sections_fallback()

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/library/sections/all"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_sections()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/sections/all"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.add_section(request=operations.AddSectionRequest(
                    name="<value>",
                    media_type=39544,
                    agent="<value>",
                    language="<value>",
                    locations=[
                        "O:\\fatboy\\Media\\Ripped\\Music",
                        "O:\\fatboy\\Media\\My Music",
                    ],
                    prefs=operations.QueryParamPrefs(),
                    relative=components.BoolInt.TRUE,
                    import_fromi_tunes=components.BoolInt.TRUE,
                ))

                assert res.slash_get_responses_200 is not None

                # Handle response
                print(res.slash_get_responses_200)
  - target: $["paths"]["/library/sections/all/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.stop_all_refreshes()

                assert res.library_sections is not None

                # Handle response
                print(res.library_sections)
  - target: $["paths"]["/library/sections/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_sections_prefs(request={
                    "media_type": 460221,
                })

                assert res.library_sections is not None

                # Handle response
                print(res.library_sections)
  - target: $["paths"]["/library/sections/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.refresh_sections_metadata(request={})

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/watchlist/all"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.get_watchlist(request={})

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_library_section(request={
                    "section_id": "<id>",
                    "async_": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_library_details(request={
                    "section_id": "<id>",
                    "include_details": components.BoolInt.TRUE,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/sections/{sectionId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.edit_section(request={
                    "section_id": "<id>",
                    "agent": "<value>",
                    "locations": [
                        "O:\\fatboy\\Media\\Ripped\\Music",
                        "O:\\fatboy\\Media\\My Music",
                    ],
                    "prefs": {},
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/agents"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_agents(request={
                    "section_id": 757906,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/library/sections/{sectionId}/albums"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_albums(request={
                    "section_id": 817133,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/all"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.list_content(request=operations.ListContentRequest(
                    media_query=components.MediaQuery(
                        type=components.MediaType.EPISODE,
                        sort="duration:desc,index",
                        source_type=2,
                    ),
                    section_id=813218,
                    include_meta=components.BoolInt.TRUE,
                    include_guids=components.BoolInt.TRUE,
                    include_collections=components.BoolInt.TRUE,
                    include_external_media=components.BoolInt.TRUE,
                    include_advanced=components.BoolInt.TRUE,
                    check_files=components.BoolInt.TRUE,
                    include_related=components.BoolInt.TRUE,
                    include_extras=components.BoolInt.TRUE,
                    include_popular_leaves=components.BoolInt.TRUE,
                    include_concerts=components.BoolInt.TRUE,
                    include_on_deck=components.BoolInt.TRUE,
                    include_chapters=components.BoolInt.TRUE,
                    include_preferences=components.BoolInt.TRUE,
                    include_bandwidths=components.BoolInt.TRUE,
                    include_loudness_ramps=components.BoolInt.TRUE,
                    include_stations=components.BoolInt.TRUE,
                    include_external_ids=components.BoolInt.TRUE,
                    include_reviews=components.BoolInt.TRUE,
                    include_credits=components.BoolInt.TRUE,
                    include_art=components.BoolInt.TRUE,
                    include_thumb=components.BoolInt.TRUE,
                    include_banner=components.BoolInt.TRUE,
                    include_theme=components.BoolInt.TRUE,
                    async_augment_metadata=components.BoolInt.TRUE,
                    async_refresh_local_media_agent=components.BoolInt.TRUE,
                    nocache=components.BoolInt.TRUE,
                    skip_refresh=components.BoolInt.TRUE,
                    unwatched=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/all"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.update_items(request={
                    "section_id": "<id>",
                    "field_locked": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/allLeaves"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_all_leaves(request={
                    "section_id": 633197,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/analyze"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.start_analysis(request={
                    "section_id": 158829,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/artists"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_artists(request={
                    "section_id": 716398,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/arts"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_arts(request={
                    "section_id": 859200,
                })

                assert res.media_container_with_artwork is not None

                # Handle response
                print(res.media_container_with_artwork)
  - target: $["paths"]["/library/sections/{sectionId}/autocomplete"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.autocomplete(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                    "section_id": 942007,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/byContentRating"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_by_content_rating(request={
                    "section_id": 586837,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/byDecade"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_by_decade(request={
                    "section_id": 212187,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/byFolder"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_by_folder(request={
                    "section_id": 352088,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/byResolution"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_by_resolution(request={
                    "section_id": 139174,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/byYear"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_by_year(request={
                    "section_id": 14634,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/categories"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_categories(request={
                    "section_id": 21841,
                })

                assert res.media_container_with_artwork is not None

                # Handle response
                print(res.media_container_with_artwork)
  - target: $["paths"]["/library/sections/{sectionId}/clips"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_clips(request={
                    "section_id": 407860,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/cluster"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_cluster(request={
                    "section_id": 138560,
                })

                assert res.media_container_with_artwork is not None

                # Handle response
                print(res.media_container_with_artwork)
  - target: $["paths"]["/library/sections/{sectionId}/collection/{collectionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_collection(request={
                    "section_id": 283619,
                    "collection_id": 680895,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/collections"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_collections(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                    "section_id": 348838,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/common"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_common(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                    "section_id": 298154,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/composite/{updatedAt}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_image(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                    "section_id": 925611,
                    "updated_at": 117413,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/computePath"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_sonic_path(request={
                    "section_id": 914549,
                    "start_id": 629990,
                    "end_id": 687740,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/edit"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_edit(request={
                    "section_id": 223075,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/edit"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.edit_library_section(request={
                    "section_id": 834094,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.empty_trash(request={
                    "section_id": 30052,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.empty_trash_post(request={
                    "section_id": 537157,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/emptyTrash"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.empty_trash_put(request={
                    "section_id": 642296,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/episodes"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_episodes(request={
                    "section_id": 229495,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/filters"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_filters(request={
                    "section_id": 380557,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/library/sections/{sectionId}/firstCharacters"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_first_characters(request={
                    "media_query": {
                        "type": components.MediaType.EPISODE,
                        "sort": "duration:desc,index",
                        "source_type": 2,
                    },
                    "section_id": 3947,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/sections/{sectionId}/hubs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_library_section_hubs(request={
                    "section_id": 426468,
                })

                assert res.media_container_with_hubs is not None

                # Handle response
                print(res.media_container_with_hubs)
  - target: $["paths"]["/library/sections/{sectionId}/indexes"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_indexes(request={
                    "section_id": 588437,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/intros"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_intros(request={
                    "section_id": 498656,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/label"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_labels(request={
                    "section_id": 705342,
                })

                assert res.media_container_with_tags is not None

                # Handle response
                print(res.media_container_with_tags)
  - target: $["paths"]["/library/sections/{sectionId}/location"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_folders(request={
                    "section_id": 892532,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/sections/{sectionId}/match"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.match_section_items(request={
                    "section_id": 31032,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/moment"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.list_moments(request={
                    "section_id": 403239,
                })

                assert res.media_container_with_artwork is not None

                # Handle response
                print(res.media_container_with_artwork)
  - target: $["paths"]["/library/sections/{sectionId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.move_section(request={
                    "section_id": 483061,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/movies"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_movies(request={
                    "section_id": 530892,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/nearest"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.content.get_sonically_similar(request={
                    "section_id": 525956,
                    "values": [],
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/newest"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_newest_for_section(request={
                    "section_id": 73900,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/onDeck"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_on_deck_for_section(request={
                    "section_id": 331089,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/optimize"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.optimize_section(request={
                    "section_id": 721290,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/optimize"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.optimize_section_post(request={
                    "section_id": 876391,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/photos"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_photos(request={
                    "section_id": 622466,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_playlists(request={
                    "section_id": 826184,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_preferences(request={
                    "section_id": 754869,
                })

                assert res.media_container_with_settings is not None

                # Handle response
                print(res.media_container_with_settings)
  - target: $["paths"]["/library/sections/{sectionId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.set_section_preferences(request={
                    "section_id": 349936,
                    "prefs": {},
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/recentlyAdded"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_recently_added_for_section(request={
                    "section_id": 46283,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.cancel_refresh(request={
                    "section_id": 326852,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.refresh_section(request={
                    "section_id": 450300,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.refresh_section_post(request={
                    "section_id": 848668,
                    "force": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/sections/{sectionId}/search"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.search_section(request={
                    "section_id": 925380,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/settings"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_settings(request={
                    "section_id": 100390,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/shows"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_shows(request={
                    "section_id": 9583,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/sections/{sectionId}/sorts"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_available_sorts(request={
                    "section_id": 212498,
                })

                assert res.media_container_with_sorts is not None

                # Handle response
                print(res.media_container_with_sorts)
  - target: $["paths"]["/library/sections/{sectionId}/tags"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_tags(request={
                    "section_id": 787543,
                })

                assert res.media_container_with_tags is not None

                # Handle response
                print(res.media_container_with_tags)
  - target: $["paths"]["/library/sections/{sectionId}/timeline"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_section_timeline(request={
                    "section_id": 670370,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/library/sections/{sectionId}/unmatch"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.unmatch_section_items(request={
                    "section_id": 209342,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/library/sections/{sectionId}/unwatched"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_unwatched_for_section(request={
                    "section_id": 483590,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.delete_stream(request={
                    "stream_id": 841510,
                    "ext": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_stream(request={
                    "stream_id": 314506,
                    "ext": "<value>",
                    "auto_adjust_subtitle": components.BoolInt.TRUE,
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/library/streams/{streamId}.{ext}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.set_stream_offset(request={
                    "stream_id": 606295,
                    "ext": "<value>",
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/library/streams/{streamId}/levels"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_stream_levels(request={
                    "stream_id": 447611,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/library/streams/{streamId}/loudness"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_stream_loudness(request={
                    "stream_id": 277271,
                })

                assert res.res is not None

                # Handle response
                print(res.res)
  - target: $["paths"]["/library/tags"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library.get_tags(request={
                    "type": components.MediaType.TV_SHOW,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/dvrs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.list_dv_rs()

                assert res.dvr_response is not None

                # Handle response
                print(res.dvr_response)
  - target: $["paths"]["/livetv/dvrs"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.create_dvr(request={
                    "lineup": "lineup://tv.plex.providers.epg.onconnect/USA-HI51418-DEFAULT",
                    "device_query_parameter": [
                        "device://tv.plex.grabbers.hdhomerun/1053C0CA",
                    ],
                    "language": "eng",
                })

                assert res.dvr_request_handler_slash_get_responses_200 is not None

                # Handle response
                print(res.dvr_request_handler_slash_get_responses_200)
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.delete_dvr(request={
                    "dvr_id": 855088,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.get_dvr(request={
                    "dvr_id": 973518,
                })

                assert res.dvr_response is not None

                # Handle response
                print(res.dvr_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["patch"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.patch_dvr_settings(request={
                    "dvr_id": 537061,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.update_dvr_settings(request={
                    "dvr_id": 614847,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/channels"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.get_dvr_channels(request={
                    "dvr_id": 901521,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/channels/{channel}/tune"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.tune_channel(request={
                    "dvr_id": 834281,
                    "channel": "2.1",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.remove_device_from_dvr(request={
                    "dvr_id": 945416,
                    "device_id": 260761,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.add_device_to_dvr(request={
                    "dvr_id": 334755,
                    "device_id": 852930,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/guide"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.get_dvr_guide(request={
                    "dvr_id": 19054,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.delete_lineup(request={
                    "dvr_id": 454470,
                    "lineup": "<value>",
                })

                assert res.dvr_response is not None

                # Handle response
                print(res.dvr_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/lineups"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.add_lineup(request={
                    "dvr_id": 945235,
                    "lineup": "<value>",
                })

                assert res.dvr_response is not None

                # Handle response
                print(res.dvr_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.set_dvr_preferences(request={
                    "dvr_id": 116357,
                })

                assert res.dvr_response is not None

                # Handle response
                print(res.dvr_response)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/recordings"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_dvr_recordings_by_dvr(request={
                    "dvr_id": 83756,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.stop_dvr_reload(request={
                    "dvr_id": 348053,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/livetv/dvrs/{dvrId}/reloadGuide"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.dv_rs.reload_guide(request={
                    "dvr_id": 140753,
                })

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/livetv/epg/channelmap"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.compute_channel_map(request={
                    "device_query_parameter": "<value>",
                    "lineup": "<value>",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/epg/channels"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_channels(request={
                    "lineup": "<value>",
                })

                assert res.channel_response is not None

                # Handle response
                print(res.channel_response)
  - target: $["paths"]["/livetv/epg/countries"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_countries()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_countries_lineups(request={
                    "country": "Malawi",
                    "epg_id": "<id>",
                })

                assert res.media_container_with_lineup is not None

                # Handle response
                print(res.media_container_with_lineup)
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_country_regions(request={
                    "country": "Morocco",
                    "epg_id": "<id>",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/epg/countries/{country}/{epgId}/regions/{region}/lineups"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.list_lineups(request={
                    "country": "Vanuatu",
                    "epg_id": "<id>",
                    "region": "<value>",
                })

                assert res.media_container_with_lineup is not None

                # Handle response
                print(res.media_container_with_lineup)
  - target: $["paths"]["/livetv/epg/guide"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_epg_guide()

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/epg/languages"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_all_languages()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/epg/lineup"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_lineup(request={
                    "device_query_parameter": "<value>",
                    "lineup_group": "<value>",
                })

                assert res.media_container_with_lineup is not None

                # Handle response
                print(res.media_container_with_lineup)
  - target: $["paths"]["/livetv/epg/lineupchannels"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.get_lineup_channels(request={
                    "lineup": [
                        "<value 1>",
                        "<value 2>",
                    ],
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/livetv/epg/search"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.epg.search_epg(request={})

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/recordings"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_dvr_recordings(request={})

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_sessions()

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/sessions/{sessionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.delete_live_tv_session(request={
                    "session_id": "<id>",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/livetv/sessions/{sessionId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_live_tv_session(request={
                    "session_id": "<id>",
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/index.m3u8"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_session_playlist_index(request={
                    "session_id": "<id>",
                    "consumer_id": "<id>",
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/livetv/sessions/{sessionId}/{consumerId}/{segmentId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.live_tv.get_session_segment(request={
                    "session_id": "<id>",
                    "consumer_id": "<id>",
                    "segment_id": "<id>",
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/log"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.log.write_log(request=open("example.file", "rb"))

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/log"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.log.write_message(request={})

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/log/networked"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.log.enable_papertrail(request={})

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/grabbers"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.get_available_grabbers(request={
                    "protocol": "livetv",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/grabbers/devices"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.list_devices()

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.add_device(request={
                    "uri": "http://10.0.0.5",
                })

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/discover"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.discover_devices()

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.remove_device(request={
                    "device_id": 685908,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.get_device_details(request={
                    "device_id": 170949,
                })

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.modify_device(request={
                    "device_id": 879135,
                    "enabled": components.BoolInt.TRUE,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channelmap"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.set_channelmap(request={
                    "device_id": 937661,
                    "channel_mapping": {},
                    "channel_mapping_by_key": {},
                    "channels_enabled": [
                        "46.1",
                        "44.1",
                        "45.1",
                    ],
                })

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/channels"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.get_devices_channels(request={
                    "device_id": 517209,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/prefs"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.set_device_preferences(request={
                    "device_id": 420973,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.stop_scan(request={
                    "device_id": 576494,
                })

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/scan"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.scan(request={
                    "device_id": 57391,
                    "source": "Cable",
                })

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/media/grabbers/devices/{deviceId}/thumb/{version}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.devices.get_thumb(request={
                    "device_id": 960617,
                    "version_path_parameter": 1025,
                })

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/media/grabbers/operations/{operationId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.cancel_grab(request={
                    "operation_id": "<id>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/providers"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.list_providers()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/providers"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.add_provider(request={
                    "url": "https://steep-obedience.name/",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/providers/refresh"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.refresh_providers()

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/providers/{provider}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.provider.delete_media_provider(request={
                    "provider": "<value>",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/subscriptions"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.get_all_subscriptions(request=operations.GetAllSubscriptionsRequest(
                    include_grabs=components.BoolInt.TRUE,
                    include_storage=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_subscription is not None

                # Handle response
                print(res.media_container_with_subscription)
  - target: $["paths"]["/media/subscriptions"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.create_subscription(request={
                    "target_library_section_id": 1,
                    "target_section_location_id": 3,
                    "media_type": 2,
                    "hints": {},
                    "prefs": {},
                    "params": {},
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/subscriptions/process"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.process_subscriptions()

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/media/subscriptions/scheduled"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.get_scheduled_recordings()

                assert res.media_container_with_media_grab_operation is not None

                # Handle response
                print(res.media_container_with_media_grab_operation)
  - target: $["paths"]["/media/subscriptions/template"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.get_template(request={
                    "guid": "plex://episode/5fc70265c40548002d539d23",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.delete_subscription(request={
                    "subscription_id": 974618,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.get_subscription(request=operations.GetSubscriptionRequest(
                    subscription_id=186713,
                    include_grabs=components.BoolInt.TRUE,
                    include_storage=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_subscription is not None

                # Handle response
                print(res.media_container_with_subscription)
  - target: $["paths"]["/media/subscriptions/{subscriptionId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.edit_subscription_preferences(request={
                    "subscription_id": 673918,
                    "prefs": {},
                })

                assert res.media_container_with_subscription is not None

                # Handle response
                print(res.media_container_with_subscription)
  - target: $["paths"]["/media/subscriptions/{subscriptionId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.subscriptions.reorder_subscription(request={
                    "subscription_id": 440634,
                })

                assert res.media_container_with_subscription is not None

                # Handle response
                print(res.media_container_with_subscription)
  - target: $["paths"]["/music/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.transcode_music(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/myplex/account"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_my_plex_account()

                assert res.user_plex_account is not None

                # Handle response
                print(res.user_plex_account)
  - target: $["paths"]["/myplex/claim"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.claim_server(request={})

                assert res.claim_token_response is not None

                # Handle response
                print(res.claim_token_response)
  - target: $["paths"]["/myplex/refreshReachability"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.refresh_reachability()

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/photo/:/transcode"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.transcode_image(request=operations.TranscodeImageRequest(
                    url="/library/metadata/265/thumb/1715112705",
                    background="#ff5522",
                    upscale=components.BoolInt.TRUE,
                    min_size=components.BoolInt.TRUE,
                    rotate=components.BoolInt.TRUE,
                    blend_color="#ff5522",
                ))

                assert res.two_hundred_image_jpeg_response_stream is not None

                # Handle response
                print(res.two_hundred_image_jpeg_response_stream)
  - target: $["paths"]["/ping"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI() as plex_api:

                res = plex_api.authentication.ping()

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/pins"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
            ) as plex_api:

                res = plex_api.authentication.create_o_auth_pin(security=operations.CreateOAuthPinSecurity(
                    client_identifier="<YOUR_API_KEY_HERE>",
                ), request={})

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/pins.xml"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.create_legacy_pin()

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/pins/link"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.link_o_auth_pin(request={
                    "auth_token": "example",
                    "pin": "example",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/pins/{pinId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
            ) as plex_api:

                res = plex_api.authentication.get_o_auth_pin(security=operations.GetOAuthPinSecurity(
                    client_identifier="<YOUR_API_KEY_HERE>",
                ), request={
                    "pin_id": 876892,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/playQueues"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.create_play_queue(request=operations.CreatePlayQueueRequest(
                    media_type=operations.Type.AUDIO,
                    shuffle=components.BoolInt.TRUE,
                    repeat=components.BoolInt.TRUE,
                    continuous=components.BoolInt.TRUE,
                    recursive=components.BoolInt.TRUE,
                    on_deck=components.BoolInt.TRUE,
                ))

                assert res.media_container_with_play_queue is not None

                # Handle response
                print(res.media_container_with_play_queue)
  - target: $["paths"]["/playQueues/1"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.timeline.get_conversion_queue(request={})

                assert res.media_container_with_play_queue is not None

                # Handle response
                print(res.media_container_with_play_queue)
  - target: $["paths"]["/playQueues/{playQueueId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.get_play_queue(request=operations.GetPlayQueueRequest(
                    play_queue_id=210646,
                    own=components.BoolInt.TRUE,
                    include_before=components.BoolInt.TRUE,
                    include_after=components.BoolInt.TRUE,
                ))

                assert res.play_queue_response is not None

                # Handle response
                print(res.play_queue_response)
  - target: $["paths"]["/playQueues/{playQueueId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.add_to_play_queue(request={
                    "play_queue_id": 919248,
                    "next": components.BoolInt.TRUE,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.clear_play_queue(request={
                    "play_queue_id": 86357,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.delete_play_queue_item(request={
                    "play_queue_id": 285738,
                    "play_queue_item_id": 464354,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/items/{playQueueItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.move_play_queue_item(request={
                    "play_queue_id": 31341,
                    "play_queue_item_id": 495865,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/reset"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.reset_play_queue(request={
                    "play_queue_id": 581891,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/shuffle"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.shuffle(request={
                    "play_queue_id": 316150,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playQueues/{playQueueId}/unshuffle"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.play_queue.unshuffle(request={
                    "play_queue_id": 484388,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/player/playback/audioStream"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_audio_stream(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/player/playback/mute"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_mute(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/pause"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_pause(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/play"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_play(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/playMedia"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_play_media(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/refreshPlayQueue"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_refreshplayqueue(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/seek"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_seek(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/setParameters"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_parameters(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/setRating"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_rating(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/setState"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_state(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/setStreams"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_streams(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/player/playback/setTextStream"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_text_stream(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/player/playback/setViewOffset"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_set_view_offset(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/skipBy"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_skip_by(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/skipTo"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_skip_to(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/stepBack"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_stepback(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/stepForward"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_stepforward(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/stop"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_stop(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/subtitleStream"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_subtitle_stream(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/player/playback/unmute"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_unmute(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/playback/videoStream"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_video_stream(request={})

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)
  - target: $["paths"]["/player/playback/volume"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_volume(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/player/resources"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.get_client_resources(request={})

                assert res.media_container_with_device is not None

                # Handle response
                print(res.media_container_with_device)
  - target: $["paths"]["/player/timeline/poll"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playback.player_poll_timeline(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/playlists"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playlists.delete_playlist_by_rating_key(request={
                    "rating_key": 499749,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/playlists"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playlist.list_playlists(request={})

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.create_playlist(request={
                    "uri": "https://short-term-disconnection.name/",
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/upload"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.upload_playlist(request={
                    "path": "/home/barkley/playlist.m3u",
                    "force": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/playlists/{playlistId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.delete_playlist(request={
                    "playlist_id": 343293,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/playlists/{playlistId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playlist.get_playlist(request={
                    "playlist_id": 841953,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/{playlistId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.update_playlist(request={
                    "playlist_id": 157966,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/playlists/{playlistId}/generators"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.get_playlist_generators(request={
                    "playlist_id": 162342,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/playlists/{playlistId}/items"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.clear_playlist_items(request={
                    "playlist_id": 552140,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/{playlistId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.playlist.get_playlist_items(request={
                    "playlist_id": 118195,
                })

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/playlists/{playlistId}/items"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.add_playlist_items(request={
                    "playlist_id": 533723,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.delete_playlist_item(request={
                    "playlist_id": 981646,
                    "generator_id": 194010,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.get_playlist_generator(request={
                    "playlist_id": 744880,
                    "generator_id": 322168,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.modify_playlist_generator(request={
                    "playlist_id": 972007,
                    "generator_id": 208334,
                    "item": {
                        "title": "Jack-Jack Attack",
                        "type": 42,
                        "location": {
                            "uri": "library://82503060-0d68-4603-b594-8b071d54819e/item/%2Flibrary%2Fmetadata%2F146",
                        },
                        "location_id": -1,
                        "policy": {
                            "scope": operations.QueryParamScope.ALL,
                        },
                        "target": "",
                        "target_tag_id": 1,
                    },
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.get_playlist_generator_items(request={
                    "playlist_id": 77230,
                    "generator_id": 979714,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/playlists/{playlistId}/items/{generatorId}/{metadataId}/{action}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.refresh_playlist(request={
                    "playlist_id": 895314,
                    "generator_id": 629742,
                    "metadata_id": 724422,
                    "action": operations.Action.DISABLE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/playlists/{playlistId}/items/{playlistItemId}/move"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.library_playlists.move_playlist_item(request={
                    "playlist_id": 940298,
                    "playlist_item_id": 375626,
                })

                assert res.media_container_with_playlist_metadata is not None

                # Handle response
                print(res.media_container_with_playlist_metadata)
  - target: $["paths"]["/resources"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.plex.get_server_resources(request={
                    "include_https": operations.IncludeHTTPS.TRUE,
                    "include_relay": operations.IncludeRelay.TRUE,
                    "include_i_pv6": operations.IncludeIPv6.TRUE,
                })

                assert res.plex_devices is not None

                # Handle response
                print(res.plex_devices)
  - target: $["paths"]["/security/resources"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_source_connection_information(request={
                    "source": "server://client-identifier",
                    "refresh": components.BoolInt.TRUE,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/security/token"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.create_transient_token(request={
                    "media_type": operations.QueryParamType.DELEGATION,
                    "scope": operations.Scope.ALL,
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/server"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_user_server(request={})

                assert res.connection_info is not None

                # Handle response
                print(res.connection_info)
  - target: $["paths"]["/server/access_tokens"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_server_access_tokens(request={})

                assert res.server_access_tokens_response is not None

                # Handle response
                print(res.server_access_tokens_response)
  - target: $["paths"]["/server/users/features"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_server_user_features(request={})

                assert res.server_user_features_response is not None

                # Handle response
                print(res.server_user_features_response)
  - target: $["paths"]["/servers"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_local_servers(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/servers/{machineId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_server_details(request={
                    "machine_id": "<id>",
                })

                assert res.server_configuration is not None

                # Handle response
                print(res.server_configuration)
  - target: $["paths"]["/servers/{machineId}/shared_servers"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.share_server_legacy(request={
                    "machine_id": "<id>",
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/services/browse"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.browse_filesystem(request={
                    "include_files": components.BoolInt.TRUE,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/services/browse/{base64path}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.browse_filesystem_path(request={
                    "base64path": "<value>",
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/services/ultrablur/colors"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.ultra_blur.get_colors(request={
                    "url": "/library/metadata/217745/art/1718931408",
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/services/ultrablur/image"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.ultra_blur.get_image(request={
                    "top_left": "3f280a",
                    "top_right": "6b4713",
                    "bottom_right": "0f2a43",
                    "bottom_left": "1c425d",
                    "width": 1920,
                    "height": 1080,
                    "noise": components.BoolInt.TRUE,
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/shared_servers"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.share_server(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/sharings/{userId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.remove_share(request={
                    "user_id": 858924,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/sharings/{userId}"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.update_share(request={
                    "user_id": 139113,
                })

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/statistics/bandwidth"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_bandwidth_statistics(request={
                    "timespan": 4,
                    "lan": components.BoolInt.TRUE,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/statistics/resources"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_resource_statistics(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/status/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.list_sessions()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/status/sessions/background"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.get_background_tasks()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/status/sessions/history/all"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.list_playback_history(request={
                    "sort": [
                        "viewedAt:desc",
                        "accountID",
                    ],
                })

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/status/sessions/history/{historyId}"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.delete_history(request={
                    "history_id": 953579,
                })

                assert res.media_container is not None

                # Handle response
                print(res.media_container)
  - target: $["paths"]["/status/sessions/history/{historyId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.get_history_item(request={
                    "history_id": 832213,
                })

                assert res.history_all_get_responses_200 is not None

                # Handle response
                print(res.history_all_get_responses_200)
  - target: $["paths"]["/status/sessions/terminate"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.status.terminate_session(request={
                    "session_id": "cdefghijklmnopqrstuvwxyz",
                    "reason": "Stop Playing",
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/sync"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_sync_status(request={})

                assert res.media_container_with_status is not None

                # Handle response
                print(res.media_container_with_status)
  - target: $["paths"]["/sync/items"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_sync_items(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/sync/items/{syncId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_sync_item(request={
                    "sync_id": 761088,
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/sync/queue"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_sync_queue(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/sync/refreshContent"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.refresh_sync_content(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/sync/refreshSynclists"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.refresh_sync_lists(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/sync/transcodeQueue"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_sync_transcode_queue(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/system/agents"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_metadata_agents(request={})

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/system/agents/{agentId}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_metadata_agent_details(request={
                    "agent_id": "<id>",
                })

                assert res.media_container_with_directory is not None

                # Handle response
                print(res.media_container_with_directory)
  - target: $["paths"]["/system/settings"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_system_settings(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/system/updates"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.check_for_system_updates(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/transcode/sessions"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.get_transcode_sessions()

                assert res.media_container_with_metadata is not None

                # Handle response
                print(res.media_container_with_metadata)
  - target: $["paths"]["/updater/apply"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.updater.apply_updates(request=operations.ApplyUpdatesRequest(
                    tonight=components.BoolInt.TRUE,
                    skip=components.BoolInt.TRUE,
                ))

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/updater/check"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.updater.check_updates(request={
                    "download": components.BoolInt.TRUE,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/updater/status"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI


            with PlexAPI(
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.updater.get_updates_status()

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/user"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.get_token_details(request={})

                assert res.user_plex_account is not None

                # Handle response
                print(res.user_plex_account)
  - target: $["paths"]["/user/view_state_sync"]["put"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.update_view_state_sync(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/user/{uuid}/settings/opt_outs"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_user_opt_outs(request={
                    "uuid": "17dd8bb4-eb45-4878-97c7-017f7d9a2384",
                })

                assert res.user_opt_outs_response is not None

                # Handle response
                print(res.user_opt_outs_response)
  - target: $["paths"]["/users"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_users(request={})

                assert res.object is not None

                # Handle response
                print(res.object)
  - target: $["paths"]["/users/account"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_account_xml(request={})

                assert res.body is not None

                # Handle response
                print(res.body)
  - target: $["paths"]["/users/account.json"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.users.get_account_json(request={})

                assert res.user_plex_account is not None

                # Handle response
                print(res.user_plex_account)
  - target: $["paths"]["/users/password"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.change_password(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/users/signin"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
            ) as plex_api:

                res = plex_api.authentication.post_users_sign_in_data(request={
                    "request_body": {
                        "login": "username@email.com",
                        "password": "password123",
                        "remember_me": True,
                        "verification_code": "123456",
                    },
                })

                assert res.user_plex_account is not None

                # Handle response
                print(res.user_plex_account)
  - target: $["paths"]["/users/signout"]["delete"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.authentication.sign_out(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/webhooks"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.get_webhooks(request={})

                assert res.webhook_payload is not None

                # Handle response
                print(res.webhook_payload)
  - target: $["paths"]["/webhooks"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.general.add_webhook(request={})

                assert res.success_response is not None

                # Handle response
                print(res.success_response)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/decision"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.make_decision(request=operations.MakeDecisionRequest(
                    transcode_type=components.TranscodeType.MUSIC,
                    advanced_subtitles=components.AdvancedSubtitles.BURN,
                    audio_boost=50,
                    audio_channel_count=5,
                    auto_adjust_quality=components.BoolInt.TRUE,
                    auto_adjust_subtitle=components.BoolInt.TRUE,
                    direct_play=components.BoolInt.TRUE,
                    direct_stream=components.BoolInt.TRUE,
                    direct_stream_audio=components.BoolInt.TRUE,
                    disable_resolution_rotation=components.BoolInt.TRUE,
                    has_mde=components.BoolInt.TRUE,
                    location=operations.Location.WAN,
                    media_buffer_size=102400,
                    media_index=0,
                    music_bitrate=5000,
                    offset=90.5,
                    part_index=0,
                    path="/library/metadata/151671",
                    peak_bitrate=12000,
                    photo_resolution="1080x1080",
                    protocol=operations.QueryParamProtocol.DASH,
                    seconds_per_segment=5,
                    subtitle_size=50,
                    subtitles=operations.Subtitles.BURN,
                    video_resolution="1080x1080",
                    copyts=components.BoolInt.TRUE,
                    video_bitrate=12000,
                    video_quality=50,
                    x_plex_client_profile_extra="add-limitation(scope=videoCodec&scopeName=*&type=upperBound&name=video.frameRate&value=60&replace=true)+append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=h264%2Chevc&audioCodec=aac&protocol=dash)",
                    x_plex_client_profile_name="generic",
                ))

                assert res.media_container_with_decision is not None

                # Handle response
                print(res.media_container_with_decision)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/fallback"]["post"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.trigger_fallback(request={
                    "transcode_type": components.TranscodeType.AUDIO,
                })

                assert res is not None

                # Handle response
                print(res)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/session/{sessionId}/{segmentId}.m4s"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.get_dash_segment(request={
                    "transcode_type": "<value>",
                    "session_id": "<id>",
                    "segment_id": "<id>",
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/session/{sessionId}/{segmentId}.ts"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.get_hls_segment(request={
                    "transcode_type": "<value>",
                    "session_id": "<id>",
                    "segment_id": "<id>",
                })

                assert res.response_stream is not None

                # Handle response
                print(res.response_stream)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/start.{extension}"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.start_transcode_session(request=operations.StartTranscodeSessionRequest(
                    transcode_type=components.TranscodeType.MUSIC,
                    advanced_subtitles=components.AdvancedSubtitles.BURN,
                    extension=operations.Extension.MPD,
                    audio_boost=50,
                    audio_channel_count=5,
                    auto_adjust_quality=components.BoolInt.TRUE,
                    auto_adjust_subtitle=components.BoolInt.TRUE,
                    direct_play=components.BoolInt.TRUE,
                    direct_stream=components.BoolInt.TRUE,
                    direct_stream_audio=components.BoolInt.TRUE,
                    disable_resolution_rotation=components.BoolInt.TRUE,
                    has_mde=components.BoolInt.TRUE,
                    location=operations.StartTranscodeSessionQueryParamLocation.WAN,
                    media_buffer_size=102400,
                    media_index=0,
                    music_bitrate=5000,
                    offset=90.5,
                    part_index=0,
                    path="/library/metadata/151671",
                    peak_bitrate=12000,
                    photo_resolution="1080x1080",
                    protocol=operations.StartTranscodeSessionQueryParamProtocol.DASH,
                    seconds_per_segment=5,
                    subtitle_size=50,
                    subtitles=operations.StartTranscodeSessionQueryParamSubtitles.BURN,
                    video_resolution="1080x1080",
                    copyts=components.BoolInt.TRUE,
                    video_bitrate=12000,
                    video_quality=50,
                    x_plex_client_profile_extra="add-limitation(scope=videoCodec&scopeName=*&type=upperBound&name=video.frameRate&value=60&replace=true)+append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=h264%2Chevc&audioCodec=aac&protocol=dash)",
                    x_plex_client_profile_name="generic",
                ))

                assert res.two_hundred_application_vnd_apple_mpegurl_binary_response is not None

                # Handle response
                print(res.two_hundred_application_vnd_apple_mpegurl_binary_response)
  - target: $["paths"]["/{transcodeType}/:/transcode/universal/subtitles"]["get"]
    update:
      x-codeSamples:
        - lang: python
          label: PlexPy
          source: |-
            from plex_api_client import PlexAPI
            from plex_api_client.models import components, operations


            with PlexAPI(
                accepts=components.Accepts.APPLICATION_XML,
                client_identifier="abc123",
                product="Plex for Roku",
                version="2.4.1",
                platform="Roku",
                platform_version="4.3 build 1057",
                device="Roku 3",
                model="4200X",
                device_vendor="Roku",
                device_name="Living Room TV",
                marketplace="googlePlay",
                token="<YOUR_API_KEY_HERE>",
            ) as plex_api:

                res = plex_api.transcoder.transcode_subtitles(request=operations.TranscodeSubtitlesRequest(
                    transcode_type=components.TranscodeType.AUDIO,
                    advanced_subtitles=components.AdvancedSubtitles.BURN,
                    audio_boost=50,
                    audio_channel_count=5,
                    auto_adjust_quality=components.BoolInt.TRUE,
                    auto_adjust_subtitle=components.BoolInt.TRUE,
                    direct_play=components.BoolInt.TRUE,
                    direct_stream=components.BoolInt.TRUE,
                    direct_stream_audio=components.BoolInt.TRUE,
                    disable_resolution_rotation=components.BoolInt.TRUE,
                    has_mde=components.BoolInt.TRUE,
                    location=operations.QueryParamLocation.WAN,
                    media_buffer_size=102400,
                    media_index=0,
                    music_bitrate=5000,
                    offset=90.5,
                    part_index=0,
                    path="/library/metadata/151671",
                    peak_bitrate=12000,
                    photo_resolution="1080x1080",
                    protocol=operations.TranscodeSubtitlesQueryParamProtocol.DASH,
                    seconds_per_segment=5,
                    subtitle_size=50,
                    subtitles=operations.QueryParamSubtitles.BURN,
                    video_resolution="1080x1080",
                    copyts=components.BoolInt.TRUE,
                    video_bitrate=12000,
                    video_quality=50,
                    x_plex_client_profile_extra="add-limitation(scope=videoCodec&scopeName=*&type=upperBound&name=video.frameRate&value=60&replace=true)+append-transcode-target-codec(type=videoProfile&context=streaming&videoCodec=h264%2Chevc&audioCodec=aac&protocol=dash)",
                    x_plex_client_profile_name="generic",
                ))

                assert res.binary_response is not None

                # Handle response
                print(res.binary_response)