1107

pending completion

Build # 1107

Build Type

Pull #512

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/emcconville/wand/commit/<a class=hub.com/emcconville/wand/commit/<a class="double-link" href="https://git"><a class=hub.com/emcconville/wand/commit/<a class="double-link" href="https://git"><a class=hub.com/emcconville/wand/commit/<a class="double-link" href="https://git"><a class=hub.com/emcconville/wand/commit/bdf70fcab701f8b68dd8789cbfcdea380fe3beee">bdf70fcab">&lt;a href=&quot;https://github.com/emcconville/wand/commit/</a><a class="double-link" href="https://github.com/emcconville/wand/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/emcconville/wand/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/emcconville/wand/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/emcconville/wand/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/emcconville/wand/commit/bdf70fcab701f8b68dd8789cbfcdea380fe3beee">bdf70fcab</a><a href="https://github.com/emcconville/wand/commit/bdf70fcab701f8b68dd8789cbfcdea380fe3beee">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/emcconville/wand/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/emcconville/wand/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/emcconville/wand/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/emcconville/wand/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/emcconville/wand/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/emcconville/wand/commit/bdf70fcab701f8b68dd8789cbfcdea380fe3beee&quot;&gt;bdf70fcab&lt;/a&gt;&lt;a href=&quot;https://github.com/emcconville/wand/commit/bdf70fcab701f8b68dd8789cbfcdea380fe3beee&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/emcconville/wand/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/emcconville/wand/commit/&amp;amp;lt;a class=&amp;amp;qu... (continued)

Pull Request Pull Request #512: Replace `c_magick_char_p` & remove memory leaks. Issue #510

Run Details

141 of 141 new or added lines in 5 files covered. (100.0%)

4149 of 4774 relevant lines covered (86.91%)

5.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.55

/wand/resource.py

""":mod:`wand.resource` --- Global resource management
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

There is the global resource to manage in MagickWand API. This module
implements automatic global resource management through reference counting.

"""
import atexit
import contextlib
import ctypes
import warnings

from .api import library
from .compat import abc, string_type
from .exceptions import TYPE_MAP, WandException
from .version import MAGICK_VERSION_NUMBER

__all__ = ('genesis', 'limits', 'shutdown', 'terminus',
           'DestroyedResourceError', 'Resource', 'ResourceLimits')


def genesis():
    """Instantiates the MagickWand API.

    .. warning::

       Don't call this function directly. Use :func:`increment_refcount()` and
       :func:`decrement_refcount()` functions instead.

    """
    library.MagickWandGenesis()


def terminus():
    """Cleans up the MagickWand API.

    .. warning::

       Don't call this function directly. Use :func:`increment_refcount()` and
       :func:`decrement_refcount()` functions instead.

    """
    if library.IsMagickWandInstantiated is None:  # pragma no cover
        library.MagickWandTerminus()
    elif library.IsMagickWandInstantiated():
        library.MagickWandTerminus()


allocation_map = {}


def allocate_ref(addr, deallocator):
    global allocation_map
    if len(allocation_map) == 0:
        genesis()
    if addr:
        allocation_map[addr] = deallocator


def deallocate_ref(addr):
    global allocation_map
    if addr in list(allocation_map):
        deallocator = allocation_map.pop(addr)
        if callable(deallocator):
            deallocator(addr)


@atexit.register
def shutdown():
    global allocation_map
    for addr in list(allocation_map):
        try:
            deallocator = allocation_map.pop(addr)
            if callable(deallocator):
                deallocator(addr)
        except KeyError:
            pass
    terminus()


class Resource(object):
    """Abstract base class for MagickWand object that requires resource
    management. Its all subclasses manage the resource semiautomatically
    and support :keyword:`with` statement as well::

        with Resource() as resource:
            # use the resource...
            pass

    It doesn't implement constructor by itself, so subclasses should
    implement it. Every constructor should assign the pointer of its
    resource data into :attr:`resource` attribute inside of :keyword:`with`
    :meth:`allocate()` context.  For example::

        class Pizza(Resource):
            '''My pizza yummy.'''

            def __init__(self):
                with self.allocate():
                    self.resource = library.NewPizza()

    .. versionadded:: 0.1.2

    """

    #: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` predicate function
    #: that returns whether the given pointer (that contains a resource data
    #: usually) is a valid resource.
    #:
    #: .. note::
    #:
    #:    It is an abstract attribute that has to be implemented
    #:    in the subclass.
    c_is_resource = NotImplemented

    #: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that destroys
    #: the :attr:`resource`.
    #:
    #: .. note::
    #:
    #:    It is an abstract attribute that has to be implemented
    #:    in the subclass.
    c_destroy_resource = NotImplemented

    #: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that gets
    #: an exception from the :attr:`resource`.
    #:
    #: .. note::
    #:
    #:    It is an abstract attribute that has to be implemented
    #:    in the subclass.
    c_get_exception = NotImplemented

    #: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that clears
    #: an exception of the :attr:`resource`.
    #:
    #: .. note::
    #:
    #:    It is an abstract attribute that has to be implemented
    #:    in the subclass.
    c_clear_exception = NotImplemented

    @property
    def resource(self):
        """Internal pointer to the resource instance. It may raise
        :exc:`DestroyedResourceError` when the resource has destroyed already.

        """
        if getattr(self, 'c_resource', None) is None:
            raise DestroyedResourceError(repr(self) + ' is destroyed already')
        return self.c_resource

    @resource.setter
    def resource(self, resource):
        # Delete the existing resource if there is one
        if getattr(self, 'c_resource', None):
            self.destroy()

        if self.c_is_resource(resource):
            self.c_resource = resource
            allocate_ref(self.c_resource, self.c_destroy_resource)
        else:
            raise TypeError(repr(resource) + ' is an invalid resource')

    @resource.deleter
    def resource(self):
        if getattr(self, 'c_resource', None):
            deallocate_ref(self.c_resource)
        self.c_resource = None

    @contextlib.contextmanager
    def allocate(self):
        """Allocates the memory for the resource explicitly. Its subclasses
        should assign the created resource into :attr:`resource` attribute
        inside of this context. For example::

            with resource.allocate():
                resource.resource = library.NewResource()

        """
        yield self

    def destroy(self):
        """Cleans up the resource explicitly. If you use the resource in
        :keyword:`with` statement, it was called implicitly so have not to
        call it.

        """
        del self.resource

    def get_exception(self):
        """Gets a current exception instance.

        :returns: a current exception. it can be ``None`` as well if any
                  errors aren't occurred
        :rtype: :class:`wand.exceptions.WandException`

        """
        severity = ctypes.c_int()
        desc = self.c_get_exception(self.resource, ctypes.byref(severity))
        if severity.value == 0:
            if desc:
                desc = library.MagickRelinquishMemory(desc)
            return
        self.c_clear_exception(self.resource)
        exc_cls = TYPE_MAP[severity.value]
        if desc:
            message = ctypes.string_at(desc)
            desc = library.MagickRelinquishMemory(desc)
        else:
            message = b''
        if not isinstance(message, string_type):
            message = message.decode(errors='replace')
        return exc_cls(message)

    def raise_exception(self, stacklevel=1):
        """Raises an exception or warning if it has occurred."""
        e = self.get_exception()
        if isinstance(e, Warning):
            warnings.warn(e, stacklevel=stacklevel + 1)
        elif isinstance(e, Exception):
            raise e

    def make_blob(self, format=None):
        raise NotImplementedError

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        self.destroy()

    def __del__(self):
        try:
            self.destroy()
        except DestroyedResourceError:
            pass


class DestroyedResourceError(WandException, ReferenceError, AttributeError):
    """An error that rises when some code tries access to an already
    destroyed resource.

    .. versionchanged:: 0.3.0
       It becomes a subtype of :exc:`wand.exceptions.WandException`.

    """


class ResourceLimits(abc.MutableMapping):
    """Wrapper for MagickCore resource limits.
    Useful for dynamically reducing system resources before attempting risky,
    or slow running, :class:`~wand.image.Image` operations.

    For example::

       from wand.image import Image
       from wand.resource import limits

       # Use 100MB of ram before writing temp data to disk.
       limits['memory'] = 1024 * 1024 * 100
       # Reject images larger than 1000x1000.
       limits['width'] = 1000
       limits['height'] = 1000

       # Debug resources used.
       with Image(filename='user.jpg') as img:
           print('Using {0} of {1} memory'.format(limits.resource('memory'),
                                                  limits['memory']))

       # Dump list of all limits.
       for label in limits:
           print('{0} => {1}'.format(label, limits[label]))

    Available resource keys:

    - ``'area'`` - Maximum `width * height` of a pixel cache before writing to
      disk.
    - ``'disk'`` - Maximum bytes used by pixel cache on disk before exception
      is thrown.
    - ``'file'`` - Maximum cache files opened at any given time.
    - ``'height'`` - Maximum height of image before exception is thrown.
    - ``'list_length'`` - Maximum images in sequence. Only available with
      recent version of ImageMagick.
    - ``'map'`` - Maximum memory map in bytes to allocated for pixel cache
      before using disk.
    - ``'memory'`` - Maximum bytes to allocated for pixel cache before using
      disk.
    - ``'thread'`` - Maximum parallel task sub-routines can spawn - if using
      OpenMP.
    - ``'throttle'`` - Total milliseconds to yield to CPU - if possible.
    - ``'time'`` - Maximum seconds before exception is thrown.
    - ``'width'`` - Maximum width of image before exception is thrown.

    .. versionadded:: 0.5.1
    """

    #: (:class:`tuple`) List of available resource types for ImageMagick-6.
    _limits6 = ('undefined', 'area', 'disk', 'file', 'map', 'memory', 'thread',
                'time', 'throttle', 'width', 'height')

    #: (:class:`tuple`) List of available resource types for ImageMagick-7.
    _limits7 = ('undefined', 'area', 'disk', 'file', 'height', 'map', 'memory',
                'thread', 'throttle', 'time', 'width', 'list_length')

    def __init__(self):
        if MAGICK_VERSION_NUMBER < 0x700:
            self.limits = self._limits6
        else:
            self.limits = self._limits7

    def __getitem__(self, r):
        return self.get_resource_limit(r)

    def __setitem__(self, r, v):
        self.set_resource_limit(r, v)

    def __delitem__(self, r):
        self[r] = 0

    def __iter__(self):
        return iter(self.limits)

    def __len__(self):
        return len(self.limits)

    def _to_idx(self, resource):
        """Helper method to map resource string to enum value."""
        return self.limits.index(resource)

    def resource(self, resource):
        """Get the current value for the resource type.

        :param resource: Resource type.
        :type resource: :class:`basestring`
        :rtype: :class:`numeric.Integral`

        .. versionadded:: 0.5.1
        """
        return library.MagickGetResource(self._to_idx(resource))

    def get_resource_limit(self, resource):
        """Get the current limit for the resource type.

        :param resource: Resource type.
        :type resource: :class:`basestring`
        :rtype: :class:`numeric.Integral`

        .. versionadded:: 0.5.1
        """
        return library.MagickGetResourceLimit(self._to_idx(resource))

    def set_resource_limit(self, resource, limit):
        """Sets a new limit for resource type.

        .. note::

            The new limit value must be equal to, or less then, the maximum
            limit defined by the :file:`policy.xml`. Any values set outside
            normal bounds will be ignored silently.

        :param resource: Resource type.
        :type resource: :class:`basestring`
        :param limit: New limit value.
        :type limit: :class:`numeric.Integral`

        .. versionadded:: 0.5.1
        """
        genesis()
        library.MagickSetResourceLimit(self._to_idx(resource), int(limit))


#: (:class:`ResourceLimits`) Helper to get & set Magick Resource Limits.
#:
#: .. versionadded:: 0.5.1
limits = ResourceLimits()

1	""":mod:`wand.resource` --- Global resource management
2	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3
4	There is the global resource to manage in MagickWand API. This module
5	implements automatic global resource management through reference counting.
6
7	"""
8	import atexit	6✔
9	import contextlib	6✔
10	import ctypes	6✔
11	import warnings	6✔
12
13	from .api import library	6✔
14	from .compat import abc, string_type	6✔
15	from .exceptions import TYPE_MAP, WandException	6✔
16	from .version import MAGICK_VERSION_NUMBER	6✔
17
18	__all__ = ('genesis', 'limits', 'shutdown', 'terminus',	6✔
19	'DestroyedResourceError', 'Resource', 'ResourceLimits')
20
21
22	def genesis():	6✔
23	"""Instantiates the MagickWand API.
24
25	.. warning::
26
27	Don't call this function directly. Use :func:`increment_refcount()` and
28	:func:`decrement_refcount()` functions instead.
29
30	"""
31	library.MagickWandGenesis()	6✔
32
33
34	def terminus():	6✔
35	"""Cleans up the MagickWand API.
36
37	.. warning::
38
39	Don't call this function directly. Use :func:`increment_refcount()` and
40	:func:`decrement_refcount()` functions instead.
41
42	"""
43	if library.IsMagickWandInstantiated is None: # pragma no cover
44	library.MagickWandTerminus()
45	elif library.IsMagickWandInstantiated():	×
46	library.MagickWandTerminus()	×
47
48
49	allocation_map = {}	6✔
50
51
52	def allocate_ref(addr, deallocator):	6✔
53	global allocation_map
54	if len(allocation_map) == 0:	6✔
55	genesis()	6✔
56	if addr:	6✔
57	allocation_map[addr] = deallocator	6✔
58
59
60	def deallocate_ref(addr):	6✔
61	global allocation_map
62	if addr in list(allocation_map):	6✔
63	deallocator = allocation_map.pop(addr)	6✔
64	if callable(deallocator):	6✔
65	deallocator(addr)	6✔
66
67
68	@atexit.register	6✔
69	def shutdown():	3✔
70	global allocation_map
71	for addr in list(allocation_map):	×
72	try:	×
73	deallocator = allocation_map.pop(addr)	×
74	if callable(deallocator):	×
75	deallocator(addr)	×
76	except KeyError:	×
77	pass	×
78	terminus()	×
79
80
81	class Resource(object):	6✔
82	"""Abstract base class for MagickWand object that requires resource
83	management. Its all subclasses manage the resource semiautomatically
84	and support :keyword:`with` statement as well::
85
86	with Resource() as resource:
87	# use the resource...
88	pass
89
90	It doesn't implement constructor by itself, so subclasses should
91	implement it. Every constructor should assign the pointer of its
92	resource data into :attr:`resource` attribute inside of :keyword:`with`
93	:meth:`allocate()` context. For example::
94
95	class Pizza(Resource):
96	'''My pizza yummy.'''
97
98	def __init__(self):
99	with self.allocate():
100	self.resource = library.NewPizza()
101
102	.. versionadded:: 0.1.2
103
104	"""
105
106	#: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` predicate function
107	#: that returns whether the given pointer (that contains a resource data
108	#: usually) is a valid resource.
109	#:
110	#: .. note::
111	#:
112	#: It is an abstract attribute that has to be implemented
113	#: in the subclass.
114	c_is_resource = NotImplemented	6✔
115
116	#: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that destroys
117	#: the :attr:`resource`.
118	#:
119	#: .. note::
120	#:
121	#: It is an abstract attribute that has to be implemented
122	#: in the subclass.
123	c_destroy_resource = NotImplemented	6✔
124
125	#: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that gets
126	#: an exception from the :attr:`resource`.
127	#:
128	#: .. note::
129	#:
130	#: It is an abstract attribute that has to be implemented
131	#: in the subclass.
132	c_get_exception = NotImplemented	6✔
133
134	#: (:class:`ctypes.CFUNCTYPE`) The :mod:`ctypes` function that clears
135	#: an exception of the :attr:`resource`.
136	#:
137	#: .. note::
138	#:
139	#: It is an abstract attribute that has to be implemented
140	#: in the subclass.
141	c_clear_exception = NotImplemented	6✔
142
143	@property	6✔
144	def resource(self):	3✔
145	"""Internal pointer to the resource instance. It may raise
146	:exc:`DestroyedResourceError` when the resource has destroyed already.
147
148	"""
149	if getattr(self, 'c_resource', None) is None:	6✔
150	raise DestroyedResourceError(repr(self) + ' is destroyed already')	6✔
151	return self.c_resource	6✔
152
153	@resource.setter	6✔
154	def resource(self, resource):	3✔
155	# Delete the existing resource if there is one
156	if getattr(self, 'c_resource', None):	6✔
157	self.destroy()	6✔
158
159	if self.c_is_resource(resource):	6✔
160	self.c_resource = resource	6✔
161	allocate_ref(self.c_resource, self.c_destroy_resource)	6✔
162	else:
163	raise TypeError(repr(resource) + ' is an invalid resource')	×
164
165	@resource.deleter	6✔
166	def resource(self):	3✔
167	if getattr(self, 'c_resource', None):	6✔
168	deallocate_ref(self.c_resource)	6✔
169	self.c_resource = None	6✔
170
171	@contextlib.contextmanager	6✔
172	def allocate(self):	3✔
173	"""Allocates the memory for the resource explicitly. Its subclasses
174	should assign the created resource into :attr:`resource` attribute
175	inside of this context. For example::
176
177	with resource.allocate():
178	resource.resource = library.NewResource()
179
180	"""
181	yield self	6✔
182
183	def destroy(self):	6✔
184	"""Cleans up the resource explicitly. If you use the resource in
185	:keyword:`with` statement, it was called implicitly so have not to
186	call it.
187
188	"""
189	del self.resource	6✔
190
191	def get_exception(self):	6✔
192	"""Gets a current exception instance.
193
194	:returns: a current exception. it can be ``None`` as well if any
195	errors aren't occurred
196	:rtype: :class:`wand.exceptions.WandException`
197
198	"""
199	severity = ctypes.c_int()	6✔
200	desc = self.c_get_exception(self.resource, ctypes.byref(severity))	6✔
201	if severity.value == 0:	6✔
202	if desc:	6✔
203	desc = library.MagickRelinquishMemory(desc)	6✔
204	return	6✔
205	self.c_clear_exception(self.resource)	6✔
206	exc_cls = TYPE_MAP[severity.value]	6✔
207	if desc:	6✔
208	message = ctypes.string_at(desc)	6✔
209	desc = library.MagickRelinquishMemory(desc)	6✔
210	else:
211	message = b''	×
212	if not isinstance(message, string_type):	6✔
213	message = message.decode(errors='replace')	6✔
214	return exc_cls(message)	6✔
215
216	def raise_exception(self, stacklevel=1):	6✔
217	"""Raises an exception or warning if it has occurred."""
218	e = self.get_exception()	6✔
219	if isinstance(e, Warning):	6✔
220	warnings.warn(e, stacklevel=stacklevel + 1)	6✔
221	elif isinstance(e, Exception):	6✔
222	raise e	6✔
223
224	def make_blob(self, format=None):	6✔
225	raise NotImplementedError	×
226
227	def __enter__(self):	6✔
228	return self	6✔
229
230	def __exit__(self, type, value, traceback):	6✔
231	self.destroy()	6✔
232
233	def __del__(self):	6✔
234	try:	6✔
235	self.destroy()	6✔
236	except DestroyedResourceError:	×
237	pass	×
238
239
240	class DestroyedResourceError(WandException, ReferenceError, AttributeError):	6✔
241	"""An error that rises when some code tries access to an already
242	destroyed resource.
243
244	.. versionchanged:: 0.3.0
245	It becomes a subtype of :exc:`wand.exceptions.WandException`.
246
247	"""
248
249
250	class ResourceLimits(abc.MutableMapping):	6✔
251	"""Wrapper for MagickCore resource limits.
252	Useful for dynamically reducing system resources before attempting risky,
253	or slow running, :class:`~wand.image.Image` operations.
254
255	For example::
256
257	from wand.image import Image
258	from wand.resource import limits
259
260	# Use 100MB of ram before writing temp data to disk.
261	limits['memory'] = 1024 * 1024 * 100
262	# Reject images larger than 1000x1000.
263	limits['width'] = 1000
264	limits['height'] = 1000
265
266	# Debug resources used.
267	with Image(filename='user.jpg') as img:
268	print('Using {0} of {1} memory'.format(limits.resource('memory'),
269	limits['memory']))
270
271	# Dump list of all limits.
272	for label in limits:
273	print('{0} => {1}'.format(label, limits[label]))
274
275	Available resource keys:
276
277	- ``'area'`` - Maximum `width * height` of a pixel cache before writing to
278	disk.
279	- ``'disk'`` - Maximum bytes used by pixel cache on disk before exception
280	is thrown.
281	- ``'file'`` - Maximum cache files opened at any given time.
282	- ``'height'`` - Maximum height of image before exception is thrown.
283	- ``'list_length'`` - Maximum images in sequence. Only available with
284	recent version of ImageMagick.
285	- ``'map'`` - Maximum memory map in bytes to allocated for pixel cache
286	before using disk.
287	- ``'memory'`` - Maximum bytes to allocated for pixel cache before using
288	disk.
289	- ``'thread'`` - Maximum parallel task sub-routines can spawn - if using
290	OpenMP.
291	- ``'throttle'`` - Total milliseconds to yield to CPU - if possible.
292	- ``'time'`` - Maximum seconds before exception is thrown.
293	- ``'width'`` - Maximum width of image before exception is thrown.
294
295	.. versionadded:: 0.5.1
296	"""
297
298	#: (:class:`tuple`) List of available resource types for ImageMagick-6.
299	_limits6 = ('undefined', 'area', 'disk', 'file', 'map', 'memory', 'thread',	6✔
300	'time', 'throttle', 'width', 'height')
301
302	#: (:class:`tuple`) List of available resource types for ImageMagick-7.
303	_limits7 = ('undefined', 'area', 'disk', 'file', 'height', 'map', 'memory',	6✔
304	'thread', 'throttle', 'time', 'width', 'list_length')
305
306	def __init__(self):	6✔
307	if MAGICK_VERSION_NUMBER < 0x700:	6✔
308	self.limits = self._limits6	6✔
309	else:
310	self.limits = self._limits7	×
311
312	def __getitem__(self, r):	6✔
313	return self.get_resource_limit(r)	6✔
314
315	def __setitem__(self, r, v):	6✔
316	self.set_resource_limit(r, v)	6✔
317
318	def __delitem__(self, r):	6✔
319	self[r] = 0	6✔
320
321	def __iter__(self):	6✔
322	return iter(self.limits)	6✔
323
324	def __len__(self):	6✔
325	return len(self.limits)	6✔
326
327	def _to_idx(self, resource):	6✔
328	"""Helper method to map resource string to enum value."""
329	return self.limits.index(resource)	6✔
330
331	def resource(self, resource):	6✔
332	"""Get the current value for the resource type.
333
334	:param resource: Resource type.
335	:type resource: :class:`basestring`
336	:rtype: :class:`numeric.Integral`
337
338	.. versionadded:: 0.5.1
339	"""
340	return library.MagickGetResource(self._to_idx(resource))	6✔
341
342	def get_resource_limit(self, resource):	6✔
343	"""Get the current limit for the resource type.
344
345	:param resource: Resource type.
346	:type resource: :class:`basestring`
347	:rtype: :class:`numeric.Integral`
348
349	.. versionadded:: 0.5.1
350	"""
351	return library.MagickGetResourceLimit(self._to_idx(resource))	6✔
352
353	def set_resource_limit(self, resource, limit):	6✔
354	"""Sets a new limit for resource type.
355
356	.. note::
357
358	The new limit value must be equal to, or less then, the maximum
359	limit defined by the :file:`policy.xml`. Any values set outside
360	normal bounds will be ignored silently.
361
362	:param resource: Resource type.
363	:type resource: :class:`basestring`
364	:param limit: New limit value.
365	:type limit: :class:`numeric.Integral`
366
367	.. versionadded:: 0.5.1
368	"""
369	genesis()	6✔
370	library.MagickSetResourceLimit(self._to_idx(resource), int(limit))	6✔
371
372
373	#: (:class:`ResourceLimits`) Helper to get & set Magick Resource Limits.
374	#:
375	#: .. versionadded:: 0.5.1
376	limits = ResourceLimits()	6✔

emcconville / wand / 1107

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous