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
|
##
## Copyright 2007, Red Hat, Inc
## see AUTHORS
##
## This software may be freely redistributed under the terms of the GNU
## general public license.
##
## 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., 675 Mass Ave, Cambridge, MA 02139, USA.
##
class ArgCompatibility(object):
"""
That class is going to test if the module that was created by module
writer if he/she obeys to the rules we put here
"""
#these are the common options can be used with all types
__common_options = ('optional','default','description')
__method_options = ('description','args') #making method declarations more generic like method_name:{'args':{...},'description':"bla bla"}
#basic types has types also
__basic_types={
'range':[1,],
'min':0,
'max':0,
'optional':False,
'description':'',
'options':[1,],
'min_length':0,
'max_length':0,
'validator':'',
'type':'',
'default':None, #its type is unknown,
'order':0
}
def __init__(self,get_args_result):
"""
The constructor initilized by the get_method_args()(the dict to test)
@param : get_args_result : The dict with all method related info
"""
self.__args_to_check = get_args_result
#what options does each of the basic_types have :
self.__valid_args={
'int':('range','min','max',),
'string':('options','min_length','max_length','validator',),
'boolean':(),
'float':('range','min','max'),
'hash':('validator',),
'list':('validator',),
}
def _is_type_options_compatible(self,argument_dict):
"""
Checks the method's argument_dict's options and looks inside
self.__valid_args to see if the used option is there
@param : argument_dict : current argument to check
@return : True of raises IncompatibleTypesException
"""
#did module writer add a key 'type'
if not argument_dict.has_key('type') or not self.__valid_args.has_key(argument_dict['type']):
raise IncompatibleTypesException("%s is not in valid options,possible ones are :%s"%(argument_dict['type'],str(self.__valid_args)))
# we will use it everytime so not make lookups
the_type = argument_dict['type']
from itertools import chain #may i use chain ?
for key,value in argument_dict.iteritems():
if key == "type":
continue
if key not in chain(self.__valid_args[the_type],self.__common_options):
raise IncompatibleTypesException("There is no option like %s in %s"%(key,the_type))
return True
def _is_basic_types_compatible(self,type_dict):
"""
Validates that if the types that were submitted with
get_method_args were compatible with our format above
in __basic_types
@param : type_dict : The type to examine
@return : True or raise IncompatibleTypesException Exception
"""
#print "The structure we got is %s:"%(type_dict)
for key,value in type_dict.iteritems():
#do we have that type
if not self.__basic_types.has_key(key):
raise IncompatibleTypesException("%s not in the basic_types"%key)
#if type matches and dont match default
#print "The key: %s its value %s and type %s"%(key,value,type(value))
if key!='default' and type(value)!=type(self.__basic_types[key]):
raise IncompatibleTypesException("The %s keyword should be in that type %s"%(key,type(self.__basic_types[key])))
return True
def is_all_arguments_registered(self,cls,method_name,arguments):
"""
Method inspects the method arguments and checks if the user
has registered all the arguments succesfully and also adds a
'order' keyword to method arguments to
"""
import inspect
from itertools import chain
#get the arguments from real object we have [args],*arg,**kwarg,[defaults]
tmp_arguments=inspect.getargspec(getattr(cls,method_name))
check_args=[arg for arg in chain(tmp_arguments[0],tmp_arguments[1:3]) if arg and arg!='self']
print "The arguments taken from the inspect are :",check_args
#the size may change of the hash so should a copy of it
copy_arguments = arguments.copy()
for compare_arg in copy_arguments.iterkeys():
if not compare_arg in check_args:
raise ArgumentRegistrationError("The argument %s is not in the %s"%(compare_arg,method_name))
else:
#should set its ordering thing
arguments[compare_arg]['order']=check_args.index(compare_arg)
return True
def validate_all(self):
"""
Validates the output for minion module's
get_method_args method
The structure that is going to be validated is in that format :
{
method_name1 : {'args':{...},
'description':"wowo"},
method_name12 : {...}
}
@return : True or raise IncompatibleTypesException Exception
"""
for method in self.__args_to_check.iterkeys():
#here we got args or description part
#check if user did submit something not in the __method_options
for method_option in self.__args_to_check[method].iterkeys():
if method_option not in self.__method_options:
raise IncompatibleTypesException("There is no option for method_name like %s,possible ones are : %s"%(method_option,str(self.__method_options)))
#check what is inside the args
if method_option == "args":
for argument in self.__args_to_check[method][method_option].itervalues():
#print argument
#check if user registered all the args and add to them ordering option!
self._is_basic_types_compatible(argument)
self._is_type_options_compatible(argument)
return True
###The Exception classes here they will be raised during the validation part
###If a module passes all the tests it is ready tobe registered
class IncompatibleTypesException(Exception):
"""
Raised when we assign some values that breaksour rules
@see ArgCompatibility class for allowed situations
"""
def __init__(self, value=None):
Exception.__init__(self)
self.value = value
def __str__(self):
return "%s" %(self.value,)
class NonExistingMethodRegistered(IncompatibleTypesException):
"""
That Exception is raised when a non existent module is
tried to be registerd we shouldnt allow that
"""
pass
class UnregisteredMethodArgument(IncompatibleTypesException):
"""
That exception is to try to remove the errors that user may
do during method registration process. If a argument is missed
to be registerted in the method that exception is Raised!
"""
pass
class NonExistingMethodRegistered(IncompatibleTypesException):
"""
Raised when module writer registers a method that doesnt
exist in his/her module class (probably by mistake)
"""
pass
class ArgumentRegistrationError(IncompatibleTypesException):
"""
When user forgets to register soem of the arguments in the list
or adds some argument that is not there
"""
pass
|
