prompt
large_stringlengths 72
9.34k
| completion
large_stringlengths 0
7.61k
|
|---|---|
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
<|fim_middle|>
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | want = "bool"
want_type = bool |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
<|fim_middle|>
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | want = "string"
want_type = str |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
<|fim_middle|>
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
<|fim_middle|>
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
<|fim_middle|>
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
<|fim_middle|>
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
<|fim_middle|>
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)] |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
<|fim_middle|>
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.__init__(self, desc)
self.schema = schema |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
<|fim_middle|>
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1 |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
<|fim_middle|>
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return self.schema.validate(pre, item) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
<|fim_middle|>
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return [self.schema.structure(accessor)] |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
<|fim_middle|>
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
<|fim_middle|>
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
<|fim_middle|>
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
<|fim_middle|>
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
<|fim_middle|>
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error()) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
<|fim_middle|>
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
<|fim_middle|>
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
<|fim_middle|>
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
<|fim_middle|>
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
<|fim_middle|>
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
<|fim_middle|>
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1 |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
<|fim_middle|>
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | (name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
<|fim_middle|>
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
<|fim_middle|>
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
<|fim_middle|>
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
<|fim_middle|>
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
<|fim_middle|>
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
<|fim_middle|>
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | Validator.__init__(self, desc, example)
self.name = name
self.schema = schema |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
<|fim_middle|>
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
<|fim_middle|>
<｜fim▁end｜> | want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
<|fim_middle|>
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.__init__(self, desc)
self.schemas = schemas |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
<|fim_middle|>
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1 |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
<|fim_middle|>
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return schema.validate(pre, structure) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
<|fim_middle|>
<｜fim▁end｜> | desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
<|fim_middle|>
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return self._example |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
<|fim_middle|>
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | desc = self.want |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
<|fim_middle|>
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return True |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
<|fim_middle|>
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return True |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
<|fim_middle|>
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | raise error.ValidatorError("{} is not a valid memory size".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
<|fim_middle|>
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines())) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
<|fim_middle|>
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | name = overwrite |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
<|fim_middle|>
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | raise error.ValidatorError("{} needs to be a dict".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
<|fim_middle|>
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return KeyValidator.structure(self, accessor, self.example) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
<|fim_middle|>
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | raise error.ValidatorError("{} needs to be a dict".format(pre)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
<|fim_middle|>
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | return False |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
<|fim_middle|>
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name)) |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def <|fim_middle|>(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def <|fim_middle|>(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def <|fim_middle|>(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def <|fim_middle|>(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def <|fim_middle|>(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def <|fim_middle|>(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def <|fim_middle|>(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def <|fim_middle|>(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def <|fim_middle|>(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | _validate_each |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def <|fim_middle|>(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def <|fim_middle|>(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def <|fim_middle|>(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def <|fim_middle|>(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | _validate_each |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def <|fim_middle|>():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | _error_lines |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def <|fim_middle|>(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def <|fim_middle|>(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def <|fim_middle|>(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def <|fim_middle|>(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def <|fim_middle|>(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | _validate_each |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def <|fim_middle|>(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def <|fim_middle|>(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def <|fim_middle|>(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def <|fim_middle|>(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def <|fim_middle|>(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def <|fim_middle|>(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | __init__ |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def <|fim_middle|>(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def <|fim_middle|>(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def structure(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | _validate |
<|file_name|>validator.py<|end_file_name|><｜fim▁begin｜>import socket
import re
from xii import error, util
# sample validator
# keys = Dict(
# [
# RequiredKey("foo", String(), desc="A string to manipulate something"),
# Key("bar", String(), desc="something usefull")
# ],
# desc="Implement this stuff as you want"
# )
class Validator():
def __init__(self, example=None, description=None):
self._description = description
self._example = example
def structure(self, accessor):
if accessor == "example":
return self._example
return self._description
class TypeCheck(Validator):
want_type = None
want = "none"
def __init__(self, example, desc=None):
if desc is None:
desc = self.want
Validator.__init__(self, example, desc)
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
class Int(TypeCheck):
want = "int"
want_type = int
class Bool(TypeCheck):
want = "bool"
want_type = bool
class String(TypeCheck):
want = "string"
want_type = str
class Ip(TypeCheck):
want = "ip"
want_type = str
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
class ByteSize(TypeCheck):
want = "memory"
want_type = str
validator = re.compile("(?P<value>\d+)(\ *)(?P<unit>[kMGT])")
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
if self.validator.match(structure):
return True
else:
raise error.ValidatorError("{} is not a valid memory size".format(pre))
class List(TypeCheck):
want = "list"
want_type = list
def __init__(self, schema, desc=None):
TypeCheck.__init__(self, desc)
self.schema = schema
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate_each(item):
return self.schema.validate(pre, item)
return sum(map(_validate_each, structure)) > 1
def structure(self, accessor):
return [self.schema.structure(accessor)]
class Or(Validator):
def __init__(self, schemas, desc=None, exclusive=True):
Validator.__init__(self, desc)
self.schemas = schemas
self.exclusive = exclusive
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def structure(self, accessor):
desc = []
descs = [ s.structure(accessor) for s in self.schemas ]
for d in descs[:-1]:
desc.append(d)
desc.append("__or__")
desc.append(descs[-1])
return desc
# Key validators --------------------------------------------------------------
class KeyValidator(Validator):
def structure(self, accessor, overwrite=None):
name = self.name
if overwrite:
name = overwrite
return ("{}".format(name), self.schema.structure(accessor))
class VariableKeys(KeyValidator):
def __init__(self, schema, example, desc=None):
KeyValidator.__init__(self, desc, example)
self.name = "*"
self.example = example
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def structure(self, accessor):
if accessor == "example":
return KeyValidator.structure(self, accessor, self.example)
return KeyValidator.structure(self, accessor)
class Key(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
KeyValidator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
class RequiredKey(KeyValidator):
def __init__(self, name, schema, desc=None, example=None):
Validator.__init__(self, desc, example)
self.name = name
self.schema = schema
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)
class Dict(TypeCheck):
want = "dictonary"
want_type = dict
def __init__(self, schemas, desc=None):
TypeCheck.__init__(self, desc)
self.schemas = schemas
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
def _validate(schema):
return schema.validate(pre, structure)
return sum(map(_validate, self.schemas)) >= 1
def <|fim_middle|>(self, accessor):
desc_dict = {}
for key, value in [s.structure(accessor) for s in self.schemas]:
desc_dict[key] = value
return desc_dict
<｜fim▁end｜> | structure |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.<｜fim▁hole｜># 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0<｜fim▁end｜> | # |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
<|fim_middle|>
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | '''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save() |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
<|fim_middle|>
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | '''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos")) |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
<|fim_middle|>
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0 |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
ve<|fim_middle|>
>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | rbose_name = _("User")
verbose_name_plural = _("Users")
> |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
re<|fim_middle|>
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | turn self.username
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
re<|fim_middle|>
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | turn value and self.id == value.id or False
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
''<|fim_middle|>
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | '
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
''<|fim_middle|>
<｜fim▁end｜> | '
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
<|fim_middle|>
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save() |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
<|fim_middle|>
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | profile.birth_date = date.today() |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
<|fim_middle|>
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | profile.address = _("address") |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
<|fim_middle|>
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | return self.balance/60 |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
re <|fim_middle|>
else:
return 0
<｜fim▁end｜> | turn int(karma['rating_score__avg'])
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
re <|fim_middle|>
<｜fim▁end｜> | turn 0
|
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def <|fim_middle|>(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | create_profile_for_user |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def <|fim_middle|>(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | balance_hours |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __<|fim_middle|>elf):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | unicode__(s |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __<|fim_middle|>elf, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | eq__(s |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def tr<|fim_middle|>elf):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def karma(self):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | ansfers_pending(s |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Copyright (C) 2010 Eduardo Robles Elvira <edulix AT gmail DOT com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from django.contrib.auth.models import User, UserManager
from django.utils.translation import ugettext_lazy as _
from django.db import models
from django.db.models import signals, Avg, Q
from datetime import date
import os
from django.conf import settings
def create_profile_for_user(sender, **kwargs):
'''
This way everytime a User is created, a Profile is created too.
'''
if kwargs['created']:
profile = Profile()
if not kwargs['instance'].__dict__.has_key("birth_date"):
profile.birth_date = date.today()
if not kwargs['instance'].__dict__.has_key("address"):
profile.address = _("address")
profile.__dict__.update(kwargs['instance'].__dict__)
profile.save()
#signals.post_save.connect(create_profile_for_user, sender=User)
class Profile(User):
'''
<<<<<<< HEAD
User with timebank settings.
=======
User with time bank settings.
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
'''
photo = models.ImageField(_("Avatar"), blank=True, null=True,
upload_to=os.path.join(settings.STATIC_DOC_ROOT, "photos"))
<<<<<<< HEAD
birth_date = models.DateField(_("Rojstni datum"), default=date.today())
address = models.CharField(_("Naslov"), max_length=100, default=_("address"))
org_name = models.CharField(_("Ime organizacije"), max_length=30, default=_("org_name"))
first_name1 = models.CharField(_("Ime zastopnika"), max_length=30, default=_("first_name"))
last_name1 = models.CharField(_("Priimek zastopnika"), max_length=30, default=_("last_name"))
email1 = models.CharField(_("E-mail zastopnika"), max_length=30, default=_("email"))
# credits in minutes
balance = models.IntegerField(default=600)
=======
birth_date = models.DateField(_("Birth date"), default=date.today())
address = models.CharField(_("Address"), max_length=100, default=_("address"))
# credits in minutes
balance = models.IntegerField(default=0)
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def balance_hours(self):
if self.balance % 60 == 0:
return self.balance/60
return self.balance/60.0
<<<<<<< HEAD
description = models.TextField(_("Opis"), max_length=300,
blank=True)
land_line = models.CharField(_("Stacionarni telefon"), max_length=20)
mobile_tlf = models.CharField(_("Mobilni telefon"), max_length=20)
email_updates = models.BooleanField(_(u"Želim prejemati novice Časovne banke"),
=======
description = models.TextField(_("Personal address"), max_length=300,
blank=True)
land_line = models.CharField(_("Land line"), max_length=20)
mobile_tlf = models.CharField(_("Mobile phone"), max_length=20)
email_updates = models.BooleanField(_("Receive email updates"),
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
default=True)
# Saving the user language allows sending emails to him in his desired
# language (among other things)
<<<<<<< HEAD
lang_code = models.CharField(_("Jezik"), max_length=10, default='')
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
=======
lang_code = models.CharField(_("Language Code"), max_length=10, default='')
class Meta:
verbose_name = _("User")
verbose_name_plural = _("Users")
>>>>>>> 2db144ba2c6c34a8f17f795a1186a524059b1aa6
def __unicode__(self):
return self.username
# Use UserManager to get the create_user method, etc.
objects = UserManager()
def __eq__(self, value):
return value and self.id == value.id or False
def transfers_pending(self):
'''
Transfers from this user which are not in a final state
'''
from serv.models import Transfer
return Transfer.objects.filter(Q(credits_payee=self) \
| Q(credits_payee=self)).filter(status__in=['r', 'd'])
def ka<|fim_middle|>elf):
'''
Average of the user's transfer scores
'''
karma = self.transfers_received.aggregate(Avg('rating_score'))
if karma['rating_score__avg']:
return int(karma['rating_score__avg'])
else:
return 0
<｜fim▁end｜> | rma(s |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜>from distutils.core import setup
setup(
name='sequencehelpers',
py_modules=['sequencehelpers'],
version='0.2.1',<｜fim▁hole｜> url='https://github.com/2achary/sequencehelpers',
download_url='https://github.com/2achary/sequence/tarball/0.2.1',
keywords=['sequence', 'single', 'distinct'],
classifiers=[],
)<｜fim▁end｜> | description="A library consisting of functions for interacting with sequences and iterables.",
author='Zach Swift',
author_email='[email protected]', |
<|file_name|>example1.py<|end_file_name|><｜fim▁begin｜># cs.???? = currentstate, any variable on the status tab in the planner can be used.
# Script = options are
# Script.Sleep(ms)
# Script.ChangeParam(name,value)
# Script.GetParam(name)
# Script.ChangeMode(mode) - same as displayed in mode setup screen 'AUTO'
# Script.WaitFor(string,timeout)
# Script.SendRC(channel,pwm,sendnow)
#
print 'Start Script'
for chan in range(1,9):
Script.SendRC(chan,1500,False)
Script.SendRC(3,Script.GetParam('RC3_MIN'),True)
Script.Sleep(5000)
while cs.lat == 0:
print 'Waiting for GPS'
Script.Sleep(1000)
print 'Got GPS'
jo = 10 * 13
print jo
Script.SendRC(3,1000,False)
Script.SendRC(4,2000,True)
cs.messages.Clear()
Script.WaitFor('ARMING MOTORS',30000)
Script.SendRC(4,1500,True)
print 'Motors Armed!'
Script.SendRC(3,1700,True)
while cs.alt < 50:
Script.Sleep(50)
Script.SendRC(5,2000,True) # acro
Script.SendRC(1,2000,False) # roll
Script.SendRC(3,1370,True) # throttle
while cs.roll > -45: # top hald 0 - 180
Script.Sleep(5)
while cs.roll < -45: # -180 - -45
Script.Sleep(5)
Script.SendRC(5,1500,False) # stabalise
Script.SendRC(1,1500,True) # level roll
Script.Sleep(2000) # 2 sec to stabalise
Script.SendRC(3,1300,True) # throttle back to land
thro = 1350 # will decend
while cs.alt > 0.1:
<｜fim▁hole｜>Script.SendRC(4,1000,True)
Script.WaitFor('DISARMING MOTORS',30000)
Script.SendRC(4,1500,True)
print 'Roll complete'<｜fim▁end｜> | Script.Sleep(300)
Script.SendRC(3,1000,False)
|
<|file_name|>whoispy.py<|end_file_name|><｜fim▁begin｜>import re
import sys
import whoisSrvDict
import whoispy_sock
import parser_branch
<｜fim▁hole｜>FAIL = '\033[91m'
ENDC = '\033[0m'
def query(domainName):
rawMsg = ""
tldName = ""
whoisSrvAddr = ""
regex = re.compile('.+\..+')
match = regex.search(domainName)
if not match:
# Invalid domain
_display_fail("Invalid domain format")
return None
# Divice TLD
regex = re.compile('\..+')
match = regex.search(domainName)
if match:
tldName = match.group()
else:
_display_fail("Can not parse TLD")
return None
# Get TLD List
if not (tldName in whoisSrvDict.get_whoisSrvDict()):
_display_fail("Not Found TLD whois server")
return None
whoisSrvAddr = whoisSrvDict.get_whoisSrvDict().get(tldName)
rawMsg = whoispy_sock.get_rawMsg(whoisSrvAddr , domainName, 43)
return parser_branch.get_parser(rawMsg, whoisSrvAddr)
# Display method
def _display_fail(msg):
sys.stdout.write( FAIL )
sys.stdout.write("%s\n" % msg)
sys.stdout.write( ENDC )
def _display_safe(msg):
sys.stdout.write( OK )
sys.stdout.write("%s\n" % msg)
sys.stdout.write( ENDC )<｜fim▁end｜> | OK = '\033[92m' |
<|file_name|>whoispy.py<|end_file_name|><｜fim▁begin｜>import re
import sys
import whoisSrvDict
import whoispy_sock
import parser_branch
OK = '\033[92m'
FAIL = '\033[91m'
ENDC = '\033[0m'
def query(domainName):
<|fim_middle|>
# Display method
def _display_fail(msg):
sys.stdout.write( FAIL )
sys.stdout.write("%s\n" % msg)
sys.stdout.write( ENDC )
def _display_safe(msg):
sys.stdout.write( OK )
sys.stdout.write("%s\n" % msg)
sys.stdout.write( ENDC )
<｜fim▁end｜> | rawMsg = ""
tldName = ""
whoisSrvAddr = ""
regex = re.compile('.+\..+')
match = regex.search(domainName)
if not match:
# Invalid domain
_display_fail("Invalid domain format")
return None
# Divice TLD
regex = re.compile('\..+')
match = regex.search(domainName)
if match:
tldName = match.group()
else:
_display_fail("Can not parse TLD")
return None
# Get TLD List
if not (tldName in whoisSrvDict.get_whoisSrvDict()):
_display_fail("Not Found TLD whois server")
return None
whoisSrvAddr = whoisSrvDict.get_whoisSrvDict().get(tldName)
rawMsg = whoispy_sock.get_rawMsg(whoisSrvAddr , domainName, 43)
return parser_branch.get_parser(rawMsg, whoisSrvAddr) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.