opuslib-next 1.1.2__py2.py3-none-any.whl

opuslib_next/__init__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# OpusLib Python Module.
+
+"""
+OpusLib Python Module.
+~~~~~~~
+
+Python bindings to the libopus, IETF low-delay audio codec
+
+:author: kalicyh <kalicyh@qq.com>
+:copyright: Copyright (c) 2025, Kalicyh
+:license: BSD 3-Clause License
+:source: <https://github.com/kalicyh/opuslib-next>
+
+"""
+
+from .exceptions import OpusError  # NOQA
+
+from .constants import *  # NOQA
+
+from .constants import OK, APPLICATION_TYPES_MAP  # NOQA
+
+from .classes import Encoder, Decoder  # NOQA
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'

opuslib_next/api/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=invalid-name
+#
+
+"""OpusLib Package."""
+
+import ctypes  # type: ignore
+
+from ctypes.util import find_library  # type: ignore
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+lib_location = find_library('opus')
+
+if lib_location is None:
+    raise Exception(
+        'Could not find Opus library. Make sure it is installed.')
+
+libopus = ctypes.CDLL(lib_location)
+
+c_int_pointer = ctypes.POINTER(ctypes.c_int)
+c_int16_pointer = ctypes.POINTER(ctypes.c_int16)
+c_float_pointer = ctypes.POINTER(ctypes.c_float)

opuslib_next/api/ctl.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=invalid-name
+
+"""CTL macros rewritten to Python
+
+Usage example:
+
+>>> import opuslib.api.decoder
+>>> import opuslib.api.ctl
+>>> dec = opuslib.api.decoder.create_state(48000, 2)
+>>> opuslib.api.decoder.decoder_ctl(dec, opuslib.api.ctl.set_gain, -15)
+>>> gain_value = opuslib.api.decoder.decoder_ctl(dec, opuslib.api.ctl.get_gain)
+
+"""
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+import ctypes  # type: ignore
+
+import opuslib_next.api
+import opuslib_next.exceptions
+
+
+def query(request):
+
+    """Query encoder/decoder with a request value"""
+
+    def inner(func, obj):
+        result_code = func(obj, request)
+
+        if result_code is not opuslib_next.OK:
+            raise opuslib_next.exceptions.OpusError(result_code)
+
+        return result_code
+
+    return inner
+
+
+def get(request, result_type):
+
+    """Get CTL value from a encoder/decoder"""
+
+    def inner(func, obj):
+        result = result_type()
+        result_code = func(obj, request, ctypes.byref(result))
+
+        if result_code is not opuslib_next.OK:
+            raise opuslib_next.exceptions.OpusError(result_code)
+
+        return result.value
+
+    return inner
+
+
+def ctl_set(request):
+
+    """Set new CTL value to a encoder/decoder"""
+
+    def inner(func, obj, value):
+        result_code = func(obj, request, value)
+        if result_code is not opuslib_next.OK:
+            raise opuslib_next.exceptions.OpusError(result_code)
+
+    return inner
+
+#
+# Generic CTLs
+#
+
+# Resets the codec state to be equivalent to a freshly initialized state
+reset_state = query(opuslib_next.RESET_STATE)  # NOQA
+
+# Gets the final state of the codec's entropy coder
+get_final_range = get(
+    opuslib_next.GET_FINAL_RANGE_REQUEST,
+    ctypes.c_uint
+)
+
+# Gets the encoder's configured bandpass or the decoder's last bandpass
+get_bandwidth = get(opuslib_next.GET_BANDWIDTH_REQUEST, ctypes.c_int)
+
+# Gets the pitch of the last decoded frame, if available
+get_pitch = get(opuslib_next.GET_PITCH_REQUEST, ctypes.c_int)
+
+# Configures the depth of signal being encoded
+set_lsb_depth = ctl_set(opuslib_next.SET_LSB_DEPTH_REQUEST)
+
+# Gets the encoder's configured signal depth
+get_lsb_depth = get(opuslib_next.GET_LSB_DEPTH_REQUEST, ctypes.c_int)
+
+#
+# Decoder related CTLs
+#
+
+# Gets the decoder's configured gain adjustment
+get_gain = get(opuslib_next.GET_GAIN_REQUEST, ctypes.c_int)
+
+# Configures decoder gain adjustment
+set_gain = ctl_set(opuslib_next.SET_GAIN_REQUEST)
+
+#
+# Encoder related CTLs
+#
+
+# Configures the encoder's computational complexity
+set_complexity = ctl_set(opuslib_next.SET_COMPLEXITY_REQUEST)
+
+# Gets the encoder's complexity configuration
+get_complexity = get(
+    opuslib_next.GET_COMPLEXITY_REQUEST, ctypes.c_int)
+
+# Configures the bitrate in the encoder
+set_bitrate = ctl_set(opuslib_next.SET_BITRATE_REQUEST)
+
+# Gets the encoder's bitrate configuration
+get_bitrate = get(opuslib_next.GET_BITRATE_REQUEST, ctypes.c_int)
+
+# Enables or disables variable bitrate (VBR) in the encoder
+set_vbr = ctl_set(opuslib_next.SET_VBR_REQUEST)
+
+# Determine if variable bitrate (VBR) is enabled in the encoder
+get_vbr = get(opuslib_next.GET_VBR_REQUEST, ctypes.c_int)
+
+# Enables or disables constrained VBR in the encoder
+set_vbr_constraint = ctl_set(opuslib_next.SET_VBR_CONSTRAINT_REQUEST)
+
+# Determine if constrained VBR is enabled in the encoder
+get_vbr_constraint = get(
+    opuslib_next.GET_VBR_CONSTRAINT_REQUEST, ctypes.c_int)
+
+# Configures mono/stereo forcing in the encoder
+set_force_channels = ctl_set(opuslib_next.SET_FORCE_CHANNELS_REQUEST)
+
+# Gets the encoder's forced channel configuration
+get_force_channels = get(
+    opuslib_next.GET_FORCE_CHANNELS_REQUEST, ctypes.c_int)
+
+# Configures the maximum bandpass that the encoder will select automatically
+set_max_bandwidth = ctl_set(opuslib_next.SET_MAX_BANDWIDTH_REQUEST)
+
+# Gets the encoder's configured maximum allowed bandpass
+get_max_bandwidth = get(
+    opuslib_next.GET_MAX_BANDWIDTH_REQUEST, ctypes.c_int)
+
+# Sets the encoder's bandpass to a specific value
+set_bandwidth = ctl_set(opuslib_next.SET_BANDWIDTH_REQUEST)
+
+# Configures the type of signal being encoded
+set_signal = ctl_set(opuslib_next.SET_SIGNAL_REQUEST)
+
+# Gets the encoder's configured signal type
+get_signal = get(opuslib_next.GET_SIGNAL_REQUEST, ctypes.c_int)
+
+# Configures the encoder's intended application
+set_application = ctl_set(opuslib_next.SET_APPLICATION_REQUEST)
+
+# Gets the encoder's configured application
+get_application = get(
+    opuslib_next.GET_APPLICATION_REQUEST, ctypes.c_int)
+
+# Gets the sampling rate the encoder or decoder was initialized with
+get_sample_rate = get(
+    opuslib_next.GET_SAMPLE_RATE_REQUEST, ctypes.c_int)
+
+# Gets the total samples of delay added by the entire codec
+get_lookahead = get(opuslib_next.GET_LOOKAHEAD_REQUEST, ctypes.c_int)
+
+# Configures the encoder's use of inband forward error correction (FEC)
+set_inband_fec = ctl_set(opuslib_next.SET_INBAND_FEC_REQUEST)
+
+# Gets encoder's configured use of inband forward error correction
+get_inband_fec = get(
+    opuslib_next.GET_INBAND_FEC_REQUEST, ctypes.c_int)
+
+# Configures the encoder's expected packet loss percentage
+set_packet_loss_perc = ctl_set(
+    opuslib_next.SET_PACKET_LOSS_PERC_REQUEST)
+
+# Gets the encoder's configured packet loss percentage
+get_packet_loss_perc = get(
+    opuslib_next.GET_PACKET_LOSS_PERC_REQUEST,
+    ctypes.c_int
+)
+
+# Configures the encoder's use of discontinuous transmission (DTX)
+set_dtx = ctl_set(opuslib_next.SET_DTX_REQUEST)
+
+# Gets encoder's configured use of discontinuous transmission
+get_dtx = get(opuslib_next.GET_DTX_REQUEST, ctypes.c_int)
+
+#
+# Other stuff
+#
+
+unimplemented = query(opuslib_next.UNIMPLEMENTED)

opuslib_next/api/decoder.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=invalid-name,too-few-public-methods
+#
+
+"""
+CTypes mapping between libopus functions and Python.
+"""
+
+import array
+import ctypes  # type: ignore
+import typing
+
+import opuslib_next
+import opuslib_next.api
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+class Decoder(ctypes.Structure):
+    """Opus decoder state.
+    This contains the complete state of an Opus decoder.
+    """
+    pass
+
+
+DecoderPointer = ctypes.POINTER(Decoder)
+
+
+libopus_get_size = opuslib_next.api.libopus.opus_decoder_get_size
+libopus_get_size.argtypes = (ctypes.c_int,)
+libopus_get_size.restype = ctypes.c_int
+libopus_get_size.__doc__ = 'Gets the size of an OpusDecoder structure'
+
+
+libopus_create = opuslib_next.api.libopus.opus_decoder_create
+libopus_create.argtypes = (
+    ctypes.c_int,
+    ctypes.c_int,
+    opuslib_next.api.c_int_pointer
+)
+libopus_create.restype = DecoderPointer
+
+
+def create_state(fs: int, channels: int) -> ctypes.Structure:
+    """
+    Allocates and initializes a decoder state.
+    Wrapper for C opus_decoder_create()
+
+    `fs` must be one of 8000, 12000, 16000, 24000, or 48000.
+
+    Internally Opus stores data at 48000 Hz, so that should be the default
+    value for Fs. However, the decoder can efficiently decode to buffers
+    at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use data
+    at the full sample rate, or knows the compressed data doesn't use the full
+    frequency range, it can request decoding at a reduced rate. Likewise, the
+    decoder is capable of filling in either mono or interleaved stereo pcm
+    buffers, at the caller's request.
+
+    :param fs: Sample rate to decode at (Hz).
+    :param int: Number of channels (1 or 2) to decode.
+    """
+    result_code = ctypes.c_int()
+
+    decoder_state = libopus_create(
+        fs,
+        channels,
+        ctypes.byref(result_code)
+    )
+
+    if result_code.value != 0:
+        raise opuslib_next.exceptions.OpusError(result_code.value)
+
+    return decoder_state
+
+
+libopus_packet_get_bandwidth = opuslib_next.api.libopus.opus_packet_get_bandwidth
+# `argtypes` must be a sequence (,) of types!
+libopus_packet_get_bandwidth.argtypes = (ctypes.c_char_p,)
+libopus_packet_get_bandwidth.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def packet_get_bandwidth(data: bytes) -> typing.Union[int, typing.Any]:
+    """Gets the bandwidth of an Opus packet."""
+    data_pointer = ctypes.c_char_p(data)
+
+    result = libopus_packet_get_bandwidth(data_pointer)
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return result
+
+
+libopus_packet_get_nb_channels = opuslib_next.api.libopus.opus_packet_get_nb_channels  # NOQA
+# `argtypes` must be a sequence (,) of types!
+libopus_packet_get_nb_channels.argtypes = (ctypes.c_char_p,)
+libopus_packet_get_nb_channels.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def packet_get_nb_channels(data: bytes) -> typing.Union[int, typing.Any]:
+    """Gets the number of channels from an Opus packet"""
+    data_pointer = ctypes.c_char_p(data)
+
+    result = libopus_packet_get_nb_channels(data_pointer)
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return result
+
+
+libopus_packet_get_nb_frames = opuslib_next.api.libopus.opus_packet_get_nb_frames
+libopus_packet_get_nb_frames.argtypes = (ctypes.c_char_p, ctypes.c_int)
+libopus_packet_get_nb_frames.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def packet_get_nb_frames(
+        data: bytes,
+        length: typing.Optional[int] = None
+) -> typing.Union[int, typing.Any]:
+    """Gets the number of frames in an Opus packet"""
+    data_pointer = ctypes.c_char_p(data)
+
+    if length is None:
+        length = len(data)
+
+    result = libopus_packet_get_nb_frames(data_pointer, ctypes.c_int(length))
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return result
+
+
+libopus_packet_get_samples_per_frame = \
+    opuslib_next.api.libopus.opus_packet_get_samples_per_frame
+libopus_packet_get_samples_per_frame.argtypes = (ctypes.c_char_p, ctypes.c_int)
+libopus_packet_get_samples_per_frame.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def packet_get_samples_per_frame(
+        data: bytes,
+        fs: int
+) -> typing.Union[int, typing.Any]:
+    """Gets the number of samples per frame from an Opus packet"""
+    data_pointer = ctypes.c_char_p(data)
+
+    result = libopus_packet_get_nb_frames(data_pointer, ctypes.c_int(fs))
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return result
+
+
+libopus_get_nb_samples = opuslib_next.api.libopus.opus_decoder_get_nb_samples
+libopus_get_nb_samples.argtypes = (
+    DecoderPointer,
+    ctypes.c_char_p,
+    ctypes.c_int32
+)
+libopus_get_nb_samples.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def get_nb_samples(
+        decoder_state: ctypes.Structure,
+        packet: bytes,
+        length: int
+) -> typing.Union[int, typing.Any]:
+    """
+    Gets the number of samples of an Opus packet.
+
+    Parameters
+    [in]	dec	OpusDecoder*: Decoder state
+    [in]	packet	char*: Opus packet
+    [in]	len	opus_int32: Length of packet
+
+    Returns
+    Number of samples
+
+    Return values
+    OPUS_BAD_ARG	Insufficient data was passed to the function
+    OPUS_INVALID_PACKET	The compressed data passed is corrupted or of an
+        unsupported type
+    """
+    result = libopus_get_nb_samples(decoder_state, packet, length)
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return result
+
+
+libopus_decode = opuslib_next.api.libopus.opus_decode
+libopus_decode.argtypes = (
+    DecoderPointer,
+    ctypes.c_char_p,
+    ctypes.c_int32,
+    opuslib_next.api.c_int16_pointer,
+    ctypes.c_int,
+    ctypes.c_int
+)
+libopus_decode.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def decode(  # pylint: disable=too-many-arguments
+        decoder_state: ctypes.Structure,
+        opus_data: bytes,
+        length: int,
+        frame_size: int,
+        decode_fec: bool,
+        channels: int = 2
+) -> typing.Union[bytes, typing.Any]:
+    """
+    Decode an Opus Frame to PCM.
+
+    Unlike the `opus_decode` function , this function takes an additional
+    parameter `channels`, which indicates the number of channels in the frame.
+    """
+    _decode_fec = int(decode_fec)
+    result = 0
+
+    pcm_size = frame_size * channels * ctypes.sizeof(ctypes.c_int16)
+    pcm = (ctypes.c_int16 * pcm_size)()
+    pcm_pointer = ctypes.cast(pcm, opuslib_next.api.c_int16_pointer)
+
+    result = libopus_decode(
+        decoder_state,
+        opus_data,
+        length,
+        pcm_pointer,
+        frame_size,
+        _decode_fec
+    )
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return array.array('h', pcm_pointer[:result * channels]).tobytes()
+
+
+libopus_decode_float = opuslib_next.api.libopus.opus_decode_float
+libopus_decode_float.argtypes = (
+    DecoderPointer,
+    ctypes.c_char_p,
+    ctypes.c_int32,
+    opuslib_next.api.c_float_pointer,
+    ctypes.c_int,
+    ctypes.c_int
+)
+libopus_decode_float.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def decode_float(  # pylint: disable=too-many-arguments
+        decoder_state: ctypes.Structure,
+        opus_data: bytes,
+        length: int,
+        frame_size: int,
+        decode_fec: bool,
+        channels: int = 2
+) -> typing.Union[bytes, typing.Any]:
+    """
+    Decode an Opus Frame.
+
+    Unlike the `opus_decode` function , this function takes an additional
+    parameter `channels`, which indicates the number of channels in the frame.
+    """
+    _decode_fec = int(decode_fec)
+
+    pcm_size = frame_size * channels * ctypes.sizeof(ctypes.c_float)
+    pcm = (ctypes.c_float * pcm_size)()
+    pcm_pointer = ctypes.cast(pcm, opuslib_next.api.c_float_pointer)
+
+    result = libopus_decode_float(
+        decoder_state,
+        opus_data,
+        length,
+        pcm_pointer,
+        frame_size,
+        _decode_fec
+    )
+
+    if result < 0:
+        raise opuslib_next.exceptions.OpusError(result)
+
+    return array.array('f', pcm[:result * channels]).tobytes()
+
+
+libopus_ctl = opuslib_next.api.libopus.opus_decoder_ctl
+libopus_ctl.argtypes = (DecoderPointer, ctypes.c_int,)
+libopus_ctl.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def decoder_ctl(
+        decoder_state: ctypes.Structure,
+        request,
+        value=None
+) -> typing.Union[int, typing.Any]:
+    if value is not None:
+        return request(libopus_ctl, decoder_state, value)
+    return request(libopus_ctl, decoder_state)
+
+
+destroy = opuslib_next.api.libopus.opus_decoder_destroy
+destroy.argtypes = (DecoderPointer,)
+destroy.restype = None
+destroy.__doc__ = 'Frees an OpusDecoder allocated by opus_decoder_create()'

opuslib_next/api/encoder.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=invalid-name
+#
+
+"""
+CTypes mapping between libopus functions and Python.
+"""
+
+import array
+import ctypes  # type: ignore
+import typing
+
+import opuslib_next
+import opuslib_next.api
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+class Encoder(ctypes.Structure):  # pylint: disable=too-few-public-methods
+    """Opus encoder state.
+    This contains the complete state of an Opus encoder.
+    """
+    pass
+
+
+EncoderPointer = ctypes.POINTER(Encoder)
+
+
+libopus_get_size = opuslib_next.api.libopus.opus_encoder_get_size
+libopus_get_size.argtypes = (ctypes.c_int,)  # must be sequence (,) of types!
+libopus_get_size.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def get_size(channels: int) -> typing.Union[int, typing.Any]:
+    """Gets the size of an OpusEncoder structure."""
+    if channels not in (1, 2):
+        raise ValueError('Wrong channels value. Must be equal to 1 or 2')
+    return libopus_get_size(channels)
+
+
+libopus_create = opuslib_next.api.libopus.opus_encoder_create
+libopus_create.argtypes = (
+    ctypes.c_int,
+    ctypes.c_int,
+    ctypes.c_int,
+    opuslib_next.api.c_int_pointer
+)
+libopus_create.restype = EncoderPointer
+
+
+def create_state(fs: int, channels: int, application: int) -> ctypes.Structure:
+    """Allocates and initializes an encoder state."""
+    result_code = ctypes.c_int()
+
+    result = libopus_create(
+        fs,
+        channels,
+        application,
+        ctypes.byref(result_code)
+    )
+
+    if result_code.value is not opuslib_next.OK:
+        raise opuslib_next.OpusError(result_code.value)
+
+    return result
+
+
+libopus_ctl = opuslib_next.api.libopus.opus_encoder_ctl
+libopus_ctl.argtypes = (EncoderPointer, ctypes.c_int,)
+libopus_ctl.restype = ctypes.c_int
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def encoder_ctl(
+        encoder_state: ctypes.Structure,
+        request,
+        value=None
+) -> typing.Union[int, typing.Any]:
+    if value is not None:
+        return request(libopus_ctl, encoder_state, value)
+    return request(libopus_ctl, encoder_state)
+
+
+libopus_encode = opuslib_next.api.libopus.opus_encode
+libopus_encode.argtypes = (
+    EncoderPointer,
+    opuslib_next.api.c_int16_pointer,
+    ctypes.c_int,
+    ctypes.c_char_p,
+    ctypes.c_int32
+)
+libopus_encode.restype = ctypes.c_int32
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def encode(
+        encoder_state: ctypes.Structure,
+        pcm_data: bytes,
+        frame_size: int,
+        max_data_bytes: int
+) -> typing.Union[bytes, typing.Any]:
+    """
+    Encodes an Opus Frame.
+
+    Returns string output payload.
+
+    Parameters:
+    [in]	st	OpusEncoder*: Encoder state
+    [in]	pcm	opus_int16*: Input signal (interleaved if 2 channels). length
+        is frame_size*channels*sizeof(opus_int16)
+    [in]	frame_size	int: Number of samples per channel in the input signal.
+        This must be an Opus frame size for the encoder's sampling rate. For
+            example, at 48 kHz the permitted values are 120, 240, 480, 960,
+            1920, and 2880. Passing in a duration of less than 10 ms
+            (480 samples at 48 kHz) will prevent the encoder from using the
+            LPC or hybrid modes.
+    [out]	data	unsigned char*: Output payload. This must contain storage
+        for at least max_data_bytes.
+    [in]	max_data_bytes	opus_int32: Size of the allocated memory for the
+        output payload. This may be used to impose an upper limit on the
+        instant bitrate, but should not be used as the only bitrate control.
+        Use OPUS_SET_BITRATE to control the bitrate.
+    """
+    pcm_pointer = ctypes.cast(pcm_data, opuslib_next.api.c_int16_pointer)
+    opus_data = (ctypes.c_char * max_data_bytes)()
+
+    result = libopus_encode(
+        encoder_state,
+        pcm_pointer,
+        frame_size,
+        opus_data,
+        max_data_bytes
+    )
+
+    if result < 0:
+        raise opuslib_next.OpusError(result)
+
+    return array.array('b', opus_data[:result]).tobytes()
+
+
+libopus_encode_float = opuslib_next.api.libopus.opus_encode_float
+libopus_encode_float.argtypes = (
+    EncoderPointer,
+    opuslib_next.api.c_float_pointer,
+    ctypes.c_int,
+    ctypes.c_char_p,
+    ctypes.c_int32
+)
+libopus_encode_float.restype = ctypes.c_int32
+
+
+# FIXME: Remove typing.Any once we have a stub for ctypes
+def encode_float(
+        encoder_state: ctypes.Structure,
+        pcm_data: bytes,
+        frame_size: int,
+        max_data_bytes: int
+) -> typing.Union[bytes, typing.Any]:
+    """Encodes an Opus frame from floating point input"""
+    pcm_pointer = ctypes.cast(pcm_data, opuslib_next.api.c_float_pointer)
+    opus_data = (ctypes.c_char * max_data_bytes)()
+
+    result = libopus_encode_float(
+        encoder_state,
+        pcm_pointer,
+        frame_size,
+        opus_data,
+        max_data_bytes
+    )
+
+    if result < 0:
+        raise opuslib_next.OpusError(result)
+
+    return array.array('b', opus_data[:result]).tobytes()
+
+
+destroy = opuslib_next.api.libopus.opus_encoder_destroy
+destroy.argtypes = (EncoderPointer,)  # must be sequence (,) of types!
+destroy.restype = None
+destroy.__doc__ = "Frees an OpusEncoder allocated by opus_encoder_create()"

opuslib_next/api/info.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=invalid-name
+#
+
+import ctypes  # type: ignore
+
+import opuslib_next.api
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+strerror = opuslib_next.api.libopus.opus_strerror
+strerror.argtypes = (ctypes.c_int,)  # must be sequence (,) of types!
+strerror.restype = ctypes.c_char_p
+strerror.__doc__ = 'Converts an opus error code into a human readable string'
+
+
+get_version_string = opuslib_next.api.libopus.opus_get_version_string
+get_version_string.argtypes = None
+get_version_string.restype = ctypes.c_char_p
+get_version_string.__doc__ = 'Gets the libopus version string'

opuslib_next/classes.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""High-level interface to a Opus decoder functions"""
+
+import typing
+
+import opuslib_next
+import opuslib_next.api
+import opuslib_next.api.ctl
+import opuslib_next.api.decoder
+import opuslib_next.api.encoder
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+class Decoder(object):
+
+    """High-Level Decoder Object."""
+
+    def __init__(self, fs: int, channels: int) -> None:
+        """
+        :param fs: Sample Rate.
+        :param channels: Number of channels.
+        """
+        self._fs = fs
+        self._channels = channels
+        self.decoder_state = opuslib_next.api.decoder.create_state(fs, channels)
+
+    def __del__(self) -> None:
+        if hasattr(self, 'decoder_state'):
+            # Destroying state only if __init__ completed successfully
+            opuslib_next.api.decoder.destroy(self.decoder_state)
+
+    def reset_state(self) -> None:
+        """
+        Resets the codec state to be equivalent to a freshly initialized state
+        """
+        opuslib_next.api.decoder.decoder_ctl(
+            self.decoder_state,
+            opuslib_next.api.ctl.reset_state
+        )
+
+    # FIXME: Remove typing.Any once we have a stub for ctypes
+    def decode(
+            self,
+            opus_data: bytes,
+            frame_size: int,
+            decode_fec: bool = False
+        ) -> typing.Union[bytes, typing.Any]:
+        """
+        Decodes given Opus data to PCM.
+        """
+        return opuslib_next.api.decoder.decode(
+            self.decoder_state,
+            opus_data,
+            len(opus_data),
+            frame_size,
+            decode_fec,
+            channels=self._channels
+        )
+
+    # FIXME: Remove typing.Any once we have a stub for ctypes
+    def decode_float(
+            self,
+            opus_data: bytes,
+            frame_size: int,
+            decode_fec: bool = False
+        ) -> typing.Union[bytes, typing.Any]:
+        """
+        Decodes given Opus data to PCM.
+        """
+        return opuslib_next.api.decoder.decode_float(
+            self.decoder_state,
+            opus_data,
+            len(opus_data),
+            frame_size,
+            decode_fec,
+            channels=self._channels
+        )
+
+    # CTL interfaces
+
+    _get_final_range = lambda self: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.get_final_range
+    )
+
+    final_range = property(_get_final_range)
+
+    _get_bandwidth = lambda self: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.get_bandwidth
+    )
+
+    bandwidth = property(_get_bandwidth)
+
+    _get_pitch = lambda self: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.get_pitch
+    )
+
+    pitch = property(_get_pitch)
+
+    _get_lsb_depth = lambda self: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.get_lsb_depth
+    )
+
+    _set_lsb_depth = lambda self, x: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.set_lsb_depth,
+        x
+    )
+
+    lsb_depth = property(_get_lsb_depth, _set_lsb_depth)
+
+    _get_gain = lambda self: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.get_gain
+    )
+
+    _set_gain = lambda self, x: opuslib_next.api.decoder.decoder_ctl(
+        self.decoder_state,
+        opuslib_next.api.ctl.set_gain,
+        x
+    )
+
+    gain = property(_get_gain, _set_gain)
+
+
+class Encoder(object):
+
+    """High-Level Encoder Object."""
+
+    def __init__(self, fs, channels, application) -> None:
+        """
+        Parameters:
+            fs : sampling rate
+            channels : number of channels
+        """
+        # Check to see if the Encoder Application Macro is available:
+        if application in list(opuslib_next.APPLICATION_TYPES_MAP.keys()):
+            application = opuslib_next.APPLICATION_TYPES_MAP[application]
+        elif application in list(opuslib_next.APPLICATION_TYPES_MAP.values()):
+            pass  # Nothing to do here
+        else:
+            raise ValueError(
+                "`application` value must be in 'voip', 'audio' or "
+                "'restricted_lowdelay'")
+
+        self._fs = fs
+        self._channels = channels
+        self._application = application
+        self.encoder_state = opuslib_next.api.encoder.create_state(
+            fs, channels, application)
+
+    def __del__(self) -> None:
+        if hasattr(self, 'encoder_state'):
+            # Destroying state only if __init__ completed successfully
+            opuslib_next.api.encoder.destroy(self.encoder_state)
+
+    def reset_state(self) -> None:
+        """
+        Resets the codec state to be equivalent to a freshly initialized state
+        """
+        opuslib_next.api.encoder.encoder_ctl(
+            self.encoder_state, opuslib_next.api.ctl.reset_state)
+
+    def encode(self, pcm_data: bytes, frame_size: int) -> bytes:
+        """
+        Encodes given PCM data as Opus.
+        """
+        return opuslib_next.api.encoder.encode(
+            self.encoder_state,
+            pcm_data,
+            frame_size,
+            len(pcm_data)
+        )
+
+    def encode_float(self, pcm_data: bytes, frame_size: int) -> bytes:
+        """
+        Encodes given PCM data as Opus.
+        """
+        return opuslib_next.api.encoder.encode_float(
+            self.encoder_state,
+            pcm_data,
+            frame_size,
+            len(pcm_data)
+        )
+
+    # CTL interfaces
+
+    _get_final_range = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state,
+        opuslib_next.api.ctl.get_final_range
+    )
+
+    final_range = property(_get_final_range)
+
+    _get_bandwidth = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_bandwidth)
+
+    bandwidth = property(_get_bandwidth)
+
+    _get_pitch = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_pitch)
+
+    pitch = property(_get_pitch)
+
+    _get_lsb_depth = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_lsb_depth)
+
+    _set_lsb_depth = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_lsb_depth, x)
+
+    lsb_depth = property(_get_lsb_depth, _set_lsb_depth)
+
+    _get_complexity = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_complexity)
+
+    _set_complexity = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_complexity, x)
+
+    complexity = property(_get_complexity, _set_complexity)
+
+    _get_bitrate = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_bitrate)
+
+    _set_bitrate = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_bitrate, x)
+
+    bitrate = property(_get_bitrate, _set_bitrate)
+
+    _get_vbr = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_vbr)
+
+    _set_vbr = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_vbr, x)
+
+    vbr = property(_get_vbr, _set_vbr)
+
+    _get_vbr_constraint = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_vbr_constraint)
+
+    _set_vbr_constraint = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_vbr_constraint, x)
+
+    vbr_constraint = property(_get_vbr_constraint, _set_vbr_constraint)
+
+    _get_force_channels = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_force_channels)
+
+    _set_force_channels = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_force_channels, x)
+
+    force_channels = property(_get_force_channels, _set_force_channels)
+
+    _get_max_bandwidth = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_max_bandwidth)
+
+    _set_max_bandwidth = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_max_bandwidth, x)
+
+    max_bandwidth = property(_get_max_bandwidth, _set_max_bandwidth)
+
+    _set_bandwidth = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_bandwidth, x)
+
+    bandwidth = property(None, _set_bandwidth)
+
+    _get_signal = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_signal)
+
+    _set_signal = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_signal, x)
+
+    signal = property(_get_signal, _set_signal)
+
+    _get_application = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_application)
+
+    _set_application = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_application, x)
+
+    application = property(_get_application, _set_application)
+
+    _get_sample_rate = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_sample_rate)
+
+    sample_rate = property(_get_sample_rate)
+
+    _get_lookahead = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_lookahead)
+
+    lookahead = property(_get_lookahead)
+
+    _get_inband_fec = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_inband_fec)
+
+    _set_inband_fec = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_inband_fec)
+
+    inband_fec = property(_get_inband_fec, _set_inband_fec)
+
+    _get_packet_loss_perc = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_packet_loss_perc)
+
+    _set_packet_loss_perc = \
+        lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+            self.encoder_state, opuslib_next.api.ctl.set_packet_loss_perc, x)
+
+    packet_loss_perc = property(_get_packet_loss_perc, _set_packet_loss_perc)
+
+    _get_dtx = lambda self: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.get_dtx)
+
+    _set_dtx = lambda self, x: opuslib_next.api.encoder.encoder_ctl(
+        self.encoder_state, opuslib_next.api.ctl.set_dtx, x)
+
+    dtx = property(_get_dtx, _set_dtx)

opuslib_next/constants.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+OpusLib constants.
+Matches to `opus_defines.h`
+"""
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+# No Error
+OK = 0
+
+# One or more invalid/out of range arguments
+BAD_ARG = -1
+
+# The mode struct passed is invalid
+BUFFER_TOO_SMALL = -2
+
+# An internal error was detected
+INTERNAL_ERROR = -3
+
+# The compressed data passed is corrupted
+INVALID_PACKET = -4
+
+# Invalid/unsupported request number
+UNIMPLEMENTED = -5
+
+# An encoder or decoder structure is invalid or already freed
+INVALID_STATE = -6
+
+# Memory allocation has failed
+ALLOC_FAIL = -7
+
+
+# Pre-defined values for CTL interface
+
+APPLICATION_VOIP = 2048
+APPLICATION_AUDIO = 2049
+APPLICATION_RESTRICTED_LOWDELAY = 2051
+
+SIGNAL_VOICE = 3001
+SIGNAL_MUSIC = 3002
+
+# Values for the various encoder CTLs
+
+SET_APPLICATION_REQUEST = 4000
+GET_APPLICATION_REQUEST = 4001
+SET_BITRATE_REQUEST = 4002
+GET_BITRATE_REQUEST = 4003
+SET_MAX_BANDWIDTH_REQUEST = 4004
+GET_MAX_BANDWIDTH_REQUEST = 4005
+SET_VBR_REQUEST = 4006
+GET_VBR_REQUEST = 4007
+SET_BANDWIDTH_REQUEST = 4008
+GET_BANDWIDTH_REQUEST = 4009
+SET_COMPLEXITY_REQUEST = 4010
+GET_COMPLEXITY_REQUEST = 4011
+SET_INBAND_FEC_REQUEST = 4012
+GET_INBAND_FEC_REQUEST = 4013
+SET_PACKET_LOSS_PERC_REQUEST = 4014
+GET_PACKET_LOSS_PERC_REQUEST = 4015
+SET_DTX_REQUEST = 4016
+GET_DTX_REQUEST = 4017
+SET_VBR_CONSTRAINT_REQUEST = 4020
+GET_VBR_CONSTRAINT_REQUEST = 4021
+SET_FORCE_CHANNELS_REQUEST = 4022
+GET_FORCE_CHANNELS_REQUEST = 4023
+SET_SIGNAL_REQUEST = 4024
+GET_SIGNAL_REQUEST = 4025
+GET_LOOKAHEAD_REQUEST = 4027
+RESET_STATE = 4028
+GET_SAMPLE_RATE_REQUEST = 4029
+GET_FINAL_RANGE_REQUEST = 4031
+GET_PITCH_REQUEST = 4033
+SET_GAIN_REQUEST = 4034
+GET_GAIN_REQUEST = 4045  # Should have been 4035
+SET_LSB_DEPTH_REQUEST = 4036
+GET_LSB_DEPTH_REQUEST = 4037
+GET_LAST_PACKET_DURATION_REQUEST = 4039
+SET_EXPERT_FRAME_DURATION_REQUEST = 4040
+GET_EXPERT_FRAME_DURATION_REQUEST = 4041
+SET_PREDICTION_DISABLED_REQUEST = 4042
+GET_PREDICTION_DISABLED_REQUEST = 4043
+
+# Don't use 4045, it's already taken by OPUS_GET_GAIN_REQUEST
+
+AUTO = -1000
+
+BANDWIDTH_NARROWBAND = 1101
+BANDWIDTH_MEDIUMBAND = 1102
+BANDWIDTH_WIDEBAND = 1103
+BANDWIDTH_SUPERWIDEBAND = 1104
+BANDWIDTH_FULLBAND = 1105
+
+APPLICATION_TYPES_MAP = {
+    'voip': APPLICATION_VOIP,
+    'audio': APPLICATION_AUDIO,
+    'restricted_lowdelay': APPLICATION_RESTRICTED_LOWDELAY,
+}

opuslib_next/exceptions.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Exceptions for OpusLib.
+"""
+
+import typing
+
+import opuslib_next.api.info
+
+__author__ = 'kalicyh <kalicyh@qq.com>'
+__copyright__ = 'Copyright (c) 2025, Kalicyh'
+__license__ = 'BSD 3-Clause License'
+
+
+class OpusError(Exception):
+
+    """
+    Generic handler for OpusLib errors from C library.
+    """
+
+    def __init__(self, code: int) -> None:
+        self.code = code
+        super().__init__()
+
+    # FIXME: Remove typing.Any once we have a stub for ctypes
+    def __str__(self) -> typing.Union[str, typing.Any]:
+        return str(opuslib_next.api.info.strerror(self.code))

opuslib_next-1.1.2.dist-info/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2025, Kalicyh
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the SvartalF nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

opuslib_next-1.1.2.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: opuslib_next
+Version: 1.1.2
+Summary: Python bindings to the libopus, IETF low-delay audio codec
+Home-page: https://github.com/kalicyh/opuslib-next
+License: BSD-3-Clause
+Author: kalicyh
+Author-email: kalicyh@qq.com
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Project-URL: Documentation, https://github.com/kalicyh/opuslib-next
+Project-URL: Repository, https://github.com/kalicyh/opuslib-next/issues
+Description-Content-Type: text/markdown
+
+# **python-opus**
+
+Python bindings to the libopus, IETF low-delay audio codec
+
+**Usage**  
+------------
+
+The usage remains the same as the original `opuslib`, except that now the library is called `opuslib_next`. You can install it using:
+
+```bash
+pip install opuslib-next
+```
+
+After installation, you can import and use it like before:
+
+```python
+import opuslib_next
+# your code here
+```
+
+**About the Fork**  
+------------
+
+Since the original author of [opuslib](https://github.com/orion-labs/opuslib) has not maintained or updated the library for a long time, I decided to fork and update it to fix issues.
+
+**Contributing**  
+-------------
+
+If you want to contribute, please follow the [pep8](http://www.python.org/dev/peps/pep-0008/) guideline and include tests.
+

opuslib_next-1.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+opuslib_next/__init__.py,sha256=B_pXMfh6GCZuzDtbWvlCZATxa4oU6t0RlEKjUgvBPfs,636
+opuslib_next/api/__init__.py,sha256=FGk-tHC8RvoGyMiFIPMA4RKHYc0M0YKArDCK3uBMtKM,645
+opuslib_next/api/ctl.py,sha256=rsfrTABTf98Xg094O1c-587qNO79GuIrVovcltmPkMY,5787
+opuslib_next/api/decoder.py,sha256=VF0SJhdiNVMhk7aqWxM_DJTjRDH7e1eVmfbnmf6mXcs,9034
+opuslib_next/api/encoder.py,sha256=tFlqMocSelzqOEktbXJd1dE_UPnawpltE0B4pmsyXis,5300
+opuslib_next/api/info.py,sha256=JdTmzdmbSpSoiaUwEYOwP4dtqQo4GnQz9ocbyYB0zv4,709
+opuslib_next/classes.py,sha256=qrcz9K_awyuqJ5zrEofqus_n0pXjyfE5bWImxtY6m-0,10823
+opuslib_next/constants.py,sha256=nDI026Bb2ET-6qtKWJJNkVZOQSA4X2KNRTJQihNAJBQ,2425
+opuslib_next/exceptions.py,sha256=s91ahMA9HClqlodvNGwSOXkx4LKurbmYOpJRJybef5w,627
+opuslib_next-1.1.2.dist-info/LICENSE,sha256=QYIcoymg8sVhmqq7eJuB1Aju-hcYLRZbkVg-vftr9Rs,1487
+opuslib_next-1.1.2.dist-info/METADATA,sha256=zJ2S8BqoHAfJIiW7Z6231dacNrKJSx20Ncp4S8AYiiY,1892
+opuslib_next-1.1.2.dist-info/WHEEL,sha256=iAMR_6Qh95yyjYIwRxyjpiFq4FhDPemrEV-SyWIQB3U,92
+opuslib_next-1.1.2.dist-info/RECORD,,

opuslib_next-1.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py2.py3-none-any