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
|
# Authors:
# Jason Gerard DeRose <jderose@redhat.com>
#
# Copyright (C) 2008 Red Hat
# see file 'COPYING' for use and warranty information
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 2 only
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
Utility classes for registering plugins, base classe for writing plugins.
"""
import inspect
import errors
def to_cli(name):
"""
Takes a Python identifier and transforms it into form suitable for the
Command Line Interface.
"""
assert isinstance(name, str)
return name.replace('__', '.').replace('_', '-')
def from_cli(cli_name):
"""
Takes a string from the Command Line Interface and transforms it into a
Python identifier.
"""
assert isinstance(cli_name, basestring)
return cli_name.replace('-', '_').replace('.', '__')
class Plugin(object):
"""
Base class for all plugins.
"""
def __get_name(self):
"""
Returns the class name of this instance.
"""
return self.__class__.__name__
name = property(__get_name)
def __repr__(self):
"""
Returns a valid Python expression that could create this plugin
instance given the appropriate environment.
"""
return '%s.%s()' % (
self.__class__.__module__,
self.__class__.__name__
)
class Proxy(object):
"""
Used to only export certain attributes into the dynamic API.
Subclasses must list names of attributes to be proxied in the __slots__
class attribute.
"""
__slots__ = (
'__obj',
'name',
)
def __init__(self, obj, proxy_name=None):
"""
Proxy attributes on `obj`.
"""
if proxy_name is None:
proxy_name = obj.__class__.__name__
assert isinstance(proxy_name, str)
object.__setattr__(self, '_Proxy__obj', obj)
object.__setattr__(self, 'name', proxy_name)
for name in self.__slots__:
object.__setattr__(self, name, getattr(obj, name))
def __setattr__(self, name, value):
"""
Proxy instances are read-only. This raises an AttributeError
anytime an attempt is made to set an attribute.
"""
raise AttributeError('cannot set %s.%s' %
(self.__class__.__name__, name)
)
def __delattr__(self, name):
"""
Proxy instances are read-only. This raises an AttributeError
anytime an attempt is made to delete an attribute.
"""
raise AttributeError('cannot del %s.%s' %
(self.__class__.__name__, name)
)
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.__obj)
def __str__(self):
return to_cli(self.name)
class Registrar(object):
def __init__(self, *allowed):
"""
`*allowed` is a list of the base classes plugins can be subclassed
from.
"""
self.__allowed = frozenset(allowed)
self.__d = {}
self.__registered = set()
assert len(self.__allowed) == len(allowed)
for base in self.__allowed:
assert inspect.isclass(base)
assert base.__name__ not in self.__d
self.__d[base.__name__] = {}
def __findbase(self, cls):
"""
If `cls` is a subclass of a base in self.__allowed, returns that
base; otherwise raises SubclassError.
"""
assert inspect.isclass(cls)
for base in self.__allowed:
if issubclass(cls, base):
return base
raise errors.SubclassError(cls, self.__allowed)
def __call__(self, cls, override=False):
"""
Register the plugin `cls`.
"""
if not inspect.isclass(cls):
raise TypeError('plugin must be a class: %r' % cls)
# Find the base class or raise SubclassError:
base = self.__findbase(cls)
sub_d = self.__d[base.__name__]
# Raise DuplicateError if this exact class was already registered:
if cls in self.__registered:
raise errors.DuplicateError(cls)
# Check override:
if cls.__name__ in sub_d:
# Must use override=True to override:
if not override:
raise errors.OverrideError(base, cls)
else:
# There was nothing already registered to override:
if override:
raise errors.MissingOverrideError(base, cls)
# The plugin is okay, add to __registered and sub_d:
self.__registered.add(cls)
sub_d[cls.__name__] = cls
def __getitem__(self, name):
"""
Returns a copy of the namespace dict of the base class named `name`.
"""
return dict(self.__d[name])
def __iter__(self):
"""
Iterates through the names of the allowed base classes.
"""
for key in self.__d:
yield key
|
