Spaces:
Runtime error
Runtime error
File size: 8,663 Bytes
d82cf6a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 |
"""Various utility functions used internally by pyglet
"""
import os
import sys
import pyglet
def asbytes(s):
if isinstance(s, bytes):
return s
elif isinstance(s, str):
return bytes(ord(c) for c in s)
else:
return bytes(s)
def asbytes_filename(s):
if isinstance(s, bytes):
return s
elif isinstance(s, str):
return s.encode(encoding=sys.getfilesystemencoding())
def asstr(s):
if s is None:
return ''
if isinstance(s, str):
return s
return s.decode("utf-8")
def with_metaclass(meta, *bases):
"""
Function from jinja2/_compat.py. License: BSD.
Use it like this::
class BaseForm:
pass
class FormType(type):
pass
class Form(with_metaclass(FormType, BaseForm)):
pass
This requires a bit of explanation: the basic idea is to make a
dummy metaclass for one level of class instantiation that replaces
itself with the actual metaclass. Because of internal type checks
we also need to make sure that we downgrade the custom metaclass
for one level to something closer to type (that's why __call__ and
__init__ comes back from type etc.).
This has the advantage over six.with_metaclass of not introducing
dummy classes into the final MRO.
"""
class MetaClass(meta):
__call__ = type.__call__
__init__ = type.__init__
def __new__(cls, name, this_bases, d):
if this_bases is None:
return type.__new__(cls, name, (), d)
return meta(name, bases, d)
return MetaClass('temporary_class', None, {})
def debug_print(enabled_or_option='debug'):
"""Get a debug printer that is enabled based on a boolean input or a pyglet option.
The debug print function returned should be used in an assert. This way it can be
optimized out when running python with the -O flag.
Usage example::
from pyglet.debug import debug_print
_debug_media = debug_print('debug_media')
def some_func():
assert _debug_media('My debug statement')
:parameters:
`enabled_or_options` : bool or str
If a bool is passed, debug printing is enabled if it is True. If str is passed
debug printing is enabled if the pyglet option with that name is True.
:returns: Function for debug printing.
"""
if isinstance(enabled_or_option, bool):
enabled = enabled_or_option
else:
enabled = pyglet.options.get(enabled_or_option, False)
if enabled:
def _debug_print(*args, **kwargs):
print(*args, **kwargs)
return True
else:
def _debug_print(*args, **kwargs):
return True
return _debug_print
class CodecRegistry:
"""Utility class for handling adding and querying of codecs."""
def __init__(self):
self._decoders = []
self._encoders = []
self._decoder_extensions = {} # Map str -> list of matching Decoders
self._encoder_extensions = {} # Map str -> list of matching Encoders
def get_encoders(self, filename=None):
"""Get a list of all encoders. If a `filename` is provided, only
encoders supporting that extension will be returned. An empty list
will be return if no encoders for that extension are available.
"""
if filename:
extension = os.path.splitext(filename)[1].lower()
return self._encoder_extensions.get(extension, [])
return self._encoders
def get_decoders(self, filename=None):
"""Get a list of all decoders. If a `filename` is provided, only
decoders supporting that extension will be returned. An empty list
will be return if no encoders for that extension are available.
"""
if filename:
extension = os.path.splitext(filename)[1].lower()
return self._decoder_extensions.get(extension, [])
return self._decoders
def add_decoders(self, module):
"""Add a decoder module. The module must define `get_decoders`. Once
added, the appropriate decoders defined in the codec will be returned by
CodecRegistry.get_decoders.
"""
for decoder in module.get_decoders():
self._decoders.append(decoder)
for extension in decoder.get_file_extensions():
if extension not in self._decoder_extensions:
self._decoder_extensions[extension] = []
self._decoder_extensions[extension].append(decoder)
def add_encoders(self, module):
"""Add an encoder module. The module must define `get_encoders`. Once
added, the appropriate encoders defined in the codec will be returned by
CodecRegistry.get_encoders.
"""
for encoder in module.get_encoders():
self._encoders.append(encoder)
for extension in encoder.get_file_extensions():
if extension not in self._encoder_extensions:
self._encoder_extensions[extension] = []
self._encoder_extensions[extension].append(encoder)
def decode(self, filename, file, **kwargs):
"""Attempt to decode a file, using the available registered decoders.
Any decoders that match the file extension will be tried first. If no
decoders match the extension, all decoders will then be tried in order.
"""
first_exception = None
for decoder in self.get_decoders(filename):
try:
return decoder.decode(filename, file, **kwargs)
except DecodeException as e:
if not first_exception:
first_exception = e
if file:
file.seek(0)
for decoder in self.get_decoders():
try:
return decoder.decode(filename, file, **kwargs)
except DecodeException:
if file:
file.seek(0)
if not first_exception:
raise DecodeException(f"No decoders available for this file type: {filename}")
raise first_exception
def encode(self, media, filename, file=None, **kwargs):
"""Attempt to encode a pyglet object to a specified format. All registered
encoders that advertise support for the specific file extension will be tried.
If no encoders are available, an EncodeException will be raised.
"""
first_exception = None
for encoder in self.get_encoders(filename):
try:
return encoder.encode(media, filename, file, **kwargs)
except EncodeException as e:
first_exception = first_exception or e
if not first_exception:
raise EncodeException(f"No Encoders are available for this extension: '{filename}'")
raise first_exception
class Decoder:
def get_file_extensions(self):
"""Return a list or tuple of accepted file extensions, e.g. ['.wav', '.ogg']
Lower-case only.
"""
raise NotImplementedError()
def decode(self, *args, **kwargs):
"""Read and decode the given file object and return an approprite
pyglet object. Throws DecodeException if there is an error.
`filename` can be a file type hint.
"""
raise NotImplementedError()
def __hash__(self):
return hash(self.__class__.__name__)
def __eq__(self, other):
return self.__class__.__name__ == other.__class__.__name__
def __repr__(self):
return "{0}{1}".format(self.__class__.__name__, self.get_file_extensions())
class Encoder:
def get_file_extensions(self):
"""Return a list or tuple of accepted file extensions, e.g. ['.wav', '.ogg']
Lower-case only.
"""
raise NotImplementedError()
def encode(self, media, filename, file):
"""Encode the given media type to the given file. `filename`
provides a hint to the file format desired. options are
encoder-specific, and unknown options should be ignored or
issue warnings.
"""
raise NotImplementedError()
def __hash__(self):
return hash(self.__class__.__name__)
def __eq__(self, other):
return self.__class__.__name__ == other.__class__.__name__
def __repr__(self):
return "{0}{1}".format(self.__class__.__name__, self.get_file_extensions())
class DecodeException(Exception):
__module__ = "CodecRegistry"
class EncodeException(Exception):
__module__ = "CodecRegistry"
|