/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/symbol_versioning.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/symbol_versioning.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
The methods here allow for api symbol versioning.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
22
24
__all__ = ['deprecated_function',
23
25
           'deprecated_in',
24
26
           'deprecated_list',
29
31
           'warn',
30
32
           ]
31
33
 
 
34
 
 
35
import warnings
 
36
# Import the 'warn' symbol so breezy can call it even if we redefine it
32
37
from warnings import warn
33
38
 
34
 
import bzrlib
 
39
import breezy
35
40
 
36
41
 
37
42
DEPRECATED_PARAMETER = "A deprecated parameter marker."
44
49
    '%s was deprecated in version 1.4.0.'
45
50
    """
46
51
    return ("%%s was deprecated in version %s."
47
 
            % bzrlib._format_version_tuple(version_tuple))
 
52
            % breezy._format_version_tuple(version_tuple))
48
53
 
49
54
 
50
55
def set_warning_method(method):
66
71
    """Generate an automatic deprecation string for a_callable.
67
72
 
68
73
    :param a_callable: The callable to substitute into deprecation_version.
69
 
    :param deprecation_version: A deprecation format warning string. This should
70
 
        have a single %s operator in it. a_callable will be turned into a nice
71
 
        python symbol and then substituted into deprecation_version.
 
74
    :param deprecation_version: A deprecation format warning string. This
 
75
        should have a single %s operator in it. a_callable will be turned into
 
76
        a nice python symbol and then substituted into deprecation_version.
72
77
    """
73
 
    # We also want to handle old-style classes, in particular exception, and
74
 
    # they don't have an im_class attribute.
75
 
    if getattr(a_callable, 'im_class', None) is None:
 
78
    if getattr(a_callable, '__self__', None) is not None:
 
79
        symbol = "%s.%s.%s" % (a_callable.__self__.__class__.__module__,
 
80
                               a_callable.__self__.__class__.__name__,
 
81
                               a_callable.__name__)
 
82
    elif getattr(a_callable, '__qualname__', None) is not None and '<' not in a_callable.__qualname__:
 
83
        symbol = "%s.%s" % (a_callable.__module__,
 
84
                            a_callable.__qualname__)
 
85
    else:
76
86
        symbol = "%s.%s" % (a_callable.__module__,
77
87
                            a_callable.__name__)
78
 
    else:
79
 
        symbol = "%s.%s.%s" % (a_callable.im_class.__module__,
80
 
                               a_callable.im_class.__name__,
81
 
                               a_callable.__name__
82
 
                               )
83
88
    return deprecation_version % symbol
84
89
 
85
90
 
91
96
 
92
97
        def decorated_function(*args, **kwargs):
93
98
            """This is the decorated function."""
94
 
            from bzrlib import trace
 
99
            from . import trace
95
100
            trace.mutter_callsite(4, "Deprecated function called")
96
101
            warn(deprecation_string(callable, deprecation_version),
97
 
                DeprecationWarning, stacklevel=2)
 
102
                 DeprecationWarning, stacklevel=2)
98
103
            return callable(*args, **kwargs)
99
104
        _populate_decorated(callable, deprecation_version, "function",
100
105
                            decorated_function)
119
124
 
120
125
        def decorated_method(self, *args, **kwargs):
121
126
            """This is the decorated method."""
122
 
            from bzrlib import trace
 
127
            from . import trace
123
128
            if callable.__name__ == '__init__':
124
129
                symbol = "%s.%s" % (self.__class__.__module__,
125
130
                                    self.__class__.__name__,
130
135
                                       callable.__name__
131
136
                                       )
132
137
            trace.mutter_callsite(4, "Deprecated method called")
133
 
            warn(deprecation_version % symbol, DeprecationWarning, stacklevel=2)
 
138
            warn(deprecation_version %
 
139
                 symbol, DeprecationWarning, stacklevel=2)
134
140
            return callable(self, *args, **kwargs)
135
141
        _populate_decorated(callable, deprecation_version, "method",
136
142
                            decorated_method)
154
160
    # def __init__(self, bad, other)
155
161
    # def __init__(self, **kwargs)
156
162
    # RBC 20060116
157
 
    return not parameter_value is DEPRECATED_PARAMETER
 
163
    return parameter_value is not DEPRECATED_PARAMETER
158
164
 
159
165
 
160
166
def _decorate_docstring(callable, deprecation_version, label,
166
172
    if len(docstring_lines) == 0:
167
173
        decorated_callable.__doc__ = deprecation_version % ("This " + label)
168
174
    elif len(docstring_lines) == 1:
169
 
        decorated_callable.__doc__ = (callable.__doc__
170
 
                                    + "\n"
171
 
                                    + "\n"
172
 
                                    + deprecation_version % ("This " + label)
173
 
                                    + "\n")
 
175
        decorated_callable.__doc__ = (
 
176
            callable.__doc__ + "\n" + "\n" +
 
177
            deprecation_version % ("This " + label) + "\n")
174
178
    else:
175
179
        spaces = len(docstring_lines[-1])
176
180
        new_doc = callable.__doc__
209
213
    is_deprecated = True
210
214
 
211
215
    def __init__(self,
212
 
        deprecation_version,
213
 
        variable_name,
214
 
        initial_value,
215
 
        advice,
216
 
        ):
 
216
                 deprecation_version,
 
217
                 variable_name,
 
218
                 initial_value,
 
219
                 advice,
 
220
                 ):
217
221
        """Create a dict that warns when read or modified.
218
222
 
219
223
        :param deprecation_version: string for the warning format to raise,
296
300
    :param error_only: Only match an 'error' filter
297
301
    :return: True if a filter is found, False otherwise
298
302
    """
299
 
    import warnings
300
303
    for filter in warnings.filters:
301
304
        if issubclass(DeprecationWarning, filter[2]):
302
305
            # This filter will effect DeprecationWarning
305
308
    return False
306
309
 
307
310
 
 
311
def _remove_filter_callable(filter):
 
312
    """Build and returns a callable removing filter from the warnings.
 
313
 
 
314
    :param filter: The filter to remove (can be None).
 
315
 
 
316
    :return: A callable that will remove filter from warnings.filters.
 
317
    """
 
318
    def cleanup():
 
319
        if filter:
 
320
            try:
 
321
                warnings.filters.remove(filter)
 
322
            except (ValueError, IndexError):
 
323
                pass
 
324
    return cleanup
 
325
 
 
326
 
308
327
def suppress_deprecation_warnings(override=True):
309
328
    """Call this function to suppress all deprecation warnings.
310
329
 
314
333
 
315
334
    :param override: If True, always set the ignore, if False, only set the
316
335
        ignore if there isn't already a filter.
 
336
 
 
337
    :return: A callable to remove the new warnings this added.
317
338
    """
318
 
    import warnings
319
339
    if not override and _check_for_filter(error_only=False):
320
340
        # If there is already a filter effecting suppress_deprecation_warnings,
321
341
        # then skip it.
322
 
        return
323
 
    warnings.filterwarnings('ignore', category=DeprecationWarning)
 
342
        filter = None
 
343
    else:
 
344
        warnings.filterwarnings('ignore', category=DeprecationWarning)
 
345
        filter = warnings.filters[0]
 
346
    return _remove_filter_callable(filter)
324
347
 
325
348
 
326
349
def activate_deprecation_warnings(override=True):
337
360
    :param override: If False, only add a filter if there isn't an error filter
338
361
        already. (This slightly differs from suppress_deprecation_warnings, in
339
362
        because it always overrides everything but -Werror).
 
363
 
 
364
    :return: A callable to remove the new warnings this added.
340
365
    """
341
 
    import warnings
342
366
    if not override and _check_for_filter(error_only=True):
343
367
        # DeprecationWarnings are already turned into errors, don't downgrade
344
368
        # them to 'default'.
345
 
        return
346
 
    warnings.filterwarnings('default', category=DeprecationWarning)
 
369
        filter = None
 
370
    else:
 
371
        warnings.filterwarnings('default', category=DeprecationWarning)
 
372
        filter = warnings.filters[0]
 
373
    return _remove_filter_callable(filter)