def ivalidate(self, data,
                 expect_header_row=True,
                 ignore_lines=0,
                 summarize=False,
                 context=None,
                 report_unexpected_exceptions=True):
        """
        Validate `data` and return a iterator over problems found.

        Use this function rather than validate() if you expect a large number
        of problems.

        Arguments
        ---------

        `data` - any source of row-oriented data, e.g., as provided by a
        `csv.reader`, or a list of lists of strings, or ...

        `expect_header_row` - does the data contain a header row (i.e., the
        first record is a list of field names)? Defaults to True.

        `ignore_lines` - ignore n lines (rows) at the beginning of the data

        `summarize` - only report problem codes, no other details

        `context` - a dictionary of any additional information to be added to
        any problems found - useful if problems are being aggregated from
        multiple validators

        `report_unexpected_exceptions` - value check function, value predicates,
        record check functions, record predicates, and other user-supplied
        validation functions may raise unexpected exceptions. If this argument
        is true, any unexpected exceptions will be reported as validation
        problems; if False, unexpected exceptions will be handled silently.

        """

        unique_sets = self._init_unique_sets() # used for unique checks
        for i, r in enumerate(data):
            if expect_header_row and i == ignore_lines:
                # r is the header row
                for p in self._apply_header_checks(i, r, summarize, context):
                    yield p
            elif i >= ignore_lines:
                # r is a data row
                skip = False
                for p in self._apply_skips(i, r, summarize,
                                                  report_unexpected_exceptions,
                                                  context):
                    if p is True:
                        skip = True
                    else:
                        yield p
                if not skip:
                    for p in self._apply_each_methods(i, r, summarize,
                                                      report_unexpected_exceptions,
                                                      context):
                        yield p # may yield a problem if an exception is raised
                    for p in self._apply_value_checks(i, r, summarize,
                                                      report_unexpected_exceptions,
                                                      context):
                        yield p
                    for p in self._apply_record_length_checks(i, r, summarize,
                                                              context):
                        yield p
                    for p in self._apply_value_predicates(i, r, summarize,
                                                          report_unexpected_exceptions,
                                                          context):
                        yield p
                    for p in self._apply_record_checks(i, r, summarize,
                                                           report_unexpected_exceptions,
                                                           context):
                        yield p
                    for p in self._apply_record_predicates(i, r, summarize,
                                                           report_unexpected_exceptions,
                                                           context):
                        yield p
                    for p in self._apply_unique_checks(i, r, unique_sets, summarize):
                        yield p
                    for p in self._apply_check_methods(i, r, summarize,
                                                       report_unexpected_exceptions,
                                                       context):
                        yield p
                    for p in self._apply_assert_methods(i, r, summarize,
                                                        report_unexpected_exceptions,
                                                        context):
                        yield p
        for p in self._apply_finally_assert_methods(summarize,
                                                    report_unexpected_exceptions,
                                                    context):
            yield p

Validate data and return a iterator over problems found .


def _init_unique_sets(self):
        """Initialise sets used for uniqueness checking."""

        ks = dict()
        for t in self._unique_checks:
            key = t[0]
            ks[key] = set() # empty set
        return ks

def
_init_unique_sets
(
self
)
:
ks
=
dict
(
)
for
t
in
self
.
_unique_checks
:
key
=
t
[
0
]
ks
[
key
]
=
set
(
)
# empty set
return
ks

Initialise sets used for uniqueness checking .


def _apply_value_checks(self, i, r,
                            summarize=False,
                            report_unexpected_exceptions=True,
                            context=None):
        """Apply value check functions on the given record `r`."""

        for field_name, check, code, message, modulus in self._value_checks:
            if i % modulus == 0: # support sampling
                fi = self._field_names.index(field_name)
                if fi < len(r): # only apply checks if there is a value
                    value = r[fi]
                    try:
                        check(value)
                    except ValueError:
                        p = {'code': code}
                        if not summarize:
                            p['message'] = message
                            p['row'] = i + 1
                            p['column'] = fi + 1
                            p['field'] = field_name
                            p['value'] = value
                            p['record'] = r
                            if context is not None: p['context'] = context
                        yield p
                    except Exception as e:
                        if report_unexpected_exceptions:
                            p = {'code': UNEXPECTED_EXCEPTION}
                            if not summarize:
                                p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                                p['row'] = i + 1
                                p['column'] = fi + 1
                                p['field'] = field_name
                                p['value'] = value
                                p['record'] = r
                                p['exception'] = e
                                p['function'] = '%s: %s' % (check.__name__,
                                                            check.__doc__)
                                if context is not None: p['context'] = context
                            yield p

def
_apply_value_checks
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
field_name
,
check
,
code
,
message
,
modulus
in
self
.
_value_checks
:
if
i
%
modulus
==
0
:
# support sampling
fi
=
self
.
_field_names
.
index
(
field_name
)
if
fi
<
len
(
r
)
:
# only apply checks if there is a value
value
=
r
[
fi
]
try
:
check
(
value
)
except
ValueError
:
p
=
{
'code'
:
code
}
if
not
summarize
:
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'column'
]
=
fi
+
1
p
[
'field'
]
=
field_name
p
[
'value'
]
=
value
p
[
'record'
]
=
r
if
context
is
not
:
p
[
'context'
]
=
context
yield
p
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'column'
]
=
fi
+
1
p
[
'field'
]
=
field_name
p
[
'value'
]
=
value
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
check
.
__name__
,
check
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p

Apply value check functions on the given record r .


def _apply_header_checks(self, i, r, summarize=False, context=None):
        """Apply header checks on the given record `r`."""

        for code, message in self._header_checks:
            if tuple(r) != self._field_names:
                p = {'code': code}
                if not summarize:
                    p['message'] = message
                    p['row'] = i + 1
                    p['record'] = tuple(r)
                    p['missing'] = set(self._field_names) - set(r)
                    p['unexpected'] = set(r) - set(self._field_names)
                    if context is not None: p['context'] = context
                yield p

def _apply_header_checks ( self , i , r , summarize = False , context = None ) : for code , message in self . _header_checks : if tuple ( r ) != self . _field_names : p = { 'code' : code } if not summarize : p [ 'message' ] = message p [ 'row' ] = i + 1 p [ 'record' ] = tuple ( r ) p [ 'missing' ] = set ( self . _field_names ) - set ( r ) p [ 'unexpected' ] = set ( r ) - set ( self . _field_names ) if context is not None : p [ 'context' ] = context yield p

Apply header checks on the given record r .


def _apply_record_length_checks(self, i, r, summarize=False, context=None):
        """Apply record length checks on the given record `r`."""

        for code, message, modulus in self._record_length_checks:
            if i % modulus == 0: # support sampling
                if len(r) != len(self._field_names):
                    p = {'code': code}
                    if not summarize:
                        p['message'] = message
                        p['row'] = i + 1
                        p['record'] = r
                        p['length'] = len(r)
                        if context is not None: p['context'] = context
                    yield p

def
_apply_record_length_checks
(
self
,
i
,
r
,
summarize
=
False
,
context
=
)
:
for
code
,
message
,
modulus
in
self
.
_record_length_checks
:
if
i
%
modulus
==
0
:
# support sampling
if
len
(
r
)
!=
len
(
self
.
_field_names
)
:
p
=
{
'code'
:
code
}
if
not
summarize
:
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'length'
]
=
len
(
r
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p

Apply record length checks on the given record r .


def _apply_value_predicates(self, i, r,
                                summarize=False,
                                report_unexpected_exceptions=True,
                                context=None):
        """Apply value predicates on the given record `r`."""

        for field_name, predicate, code, message, modulus in self._value_predicates:
            if i % modulus == 0: # support sampling
                fi = self._field_names.index(field_name)
                if fi < len(r): # only apply predicate if there is a value
                    value = r[fi]
                    try:
                        valid = predicate(value)
                        if not valid:
                            p = {'code': code}
                            if not summarize:
                                p['message'] = message
                                p['row'] = i + 1
                                p['column'] = fi + 1
                                p['field'] = field_name
                                p['value'] = value
                                p['record'] = r
                                if context is not None: p['context'] = context
                            yield p
                    except Exception as e:
                        if report_unexpected_exceptions:
                            p = {'code': UNEXPECTED_EXCEPTION}
                            if not summarize:
                                p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                                p['row'] = i + 1
                                p['column'] = fi + 1
                                p['field'] = field_name
                                p['value'] = value
                                p['record'] = r
                                p['exception'] = e
                                p['function'] = '%s: %s' % (predicate.__name__,
                                                            predicate.__doc__)
                                if context is not None: p['context'] = context
                            yield p

Apply value predicates on the given record r .


def _apply_record_checks(self, i, r,
                                 summarize=False,
                                 report_unexpected_exceptions=True,
                                 context=None):
        """Apply record checks on `r`."""

        for check, modulus in self._record_checks:
            if i % modulus == 0: # support sampling
                rdict = self._as_dict(r)
                try:
                    check(rdict)
                except RecordError as e:
                    code = e.code if e.code is not None else RECORD_CHECK_FAILED
                    p = {'code': code}
                    if not summarize:
                        message = e.message if e.message is not None else MESSAGES[RECORD_CHECK_FAILED]
                        p['message'] = message
                        p['row'] = i + 1
                        p['record'] = r
                        if context is not None: p['context'] = context
                        if e.details is not None: p['details'] = e.details
                    yield p
                except Exception as e:
                    if report_unexpected_exceptions:
                        p = {'code': UNEXPECTED_EXCEPTION}
                        if not summarize:
                            p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                            p['row'] = i + 1
                            p['record'] = r
                            p['exception'] = e
                            p['function'] = '%s: %s' % (check.__name__,
                                                        check.__doc__)
                            if context is not None: p['context'] = context
                        yield p

def
_apply_record_checks
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
check
,
modulus
in
self
.
_record_checks
:
if
i
%
modulus
==
0
:
# support sampling
rdict
=
self
.
_as_dict
(
r
)
try
:
check
(
rdict
)
except
RecordError
as
e
:
code
=
e
.
code
if
e
.
code
is
not
else
RECORD_CHECK_FAILED
p
=
{
'code'
:
code
}
if
not
summarize
:
message
=
e
.
message
if
e
.
message
is
not
else
MESSAGES
[
RECORD_CHECK_FAILED
]
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
if
context
is
not
:
p
[
'context'
]
=
context
if
e
.
details
is
not
:
p
[
'details'
]
=
e
.
details
yield
p
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
check
.
__name__
,
check
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _apply_record_predicates(self, i, r,
                                 summarize=False,
                                 report_unexpected_exceptions=True,
                                 context=None):
        """Apply record predicates on `r`."""

        for predicate, code, message, modulus in self._record_predicates:
            if i % modulus == 0: # support sampling
                rdict = self._as_dict(r)
                try:
                    valid = predicate(rdict)
                    if not valid:
                        p = {'code': code}
                        if not summarize:
                            p['message'] = message
                            p['row'] = i + 1
                            p['record'] = r
                            if context is not None: p['context'] = context
                        yield p
                except Exception as e:
                    if report_unexpected_exceptions:
                        p = {'code': UNEXPECTED_EXCEPTION}
                        if not summarize:
                            p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                            p['row'] = i + 1
                            p['record'] = r
                            p['exception'] = e
                            p['function'] = '%s: %s' % (predicate.__name__,
                                                        predicate.__doc__)
                            if context is not None: p['context'] = context
                        yield p

def
_apply_record_predicates
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
predicate
,
code
,
message
,
modulus
in
self
.
_record_predicates
:
if
i
%
modulus
==
0
:
# support sampling
rdict
=
self
.
_as_dict
(
r
)
try
:
valid
=
predicate
(
rdict
)
if
not
valid
:
p
=
{
'code'
:
code
}
if
not
summarize
:
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
if
context
is
not
:
p
[
'context'
]
=
context
yield
p
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
predicate
.
__name__
,
predicate
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _apply_unique_checks(self, i, r, unique_sets,
                             summarize=False,
                             context=None):
        """Apply unique checks on `r`."""

        for key, code, message in self._unique_checks:
            value = None
            values = unique_sets[key]
            if isinstance(key, basestring): # assume key is a field name
                fi = self._field_names.index(key)
                if fi >= len(r):
                    continue
                value = r[fi]
            else: # assume key is a list or tuple, i.e., compound key
                value = []
                for f in key:
                    fi = self._field_names.index(f)
                    if fi >= len(r):
                        break
                    value.append(r[fi])
                value = tuple(value) # enable hashing
            if value in values:
                p = {'code': code}
                if not summarize:
                    p['message'] = message
                    p['row'] = i + 1
                    p['record'] = r
                    p['key'] = key
                    p['value'] = value
                    if context is not None: p['context'] = context
                yield p
            values.add(value)


def _apply_each_methods(self, i, r,
                            summarize=False,
                            report_unexpected_exceptions=True,
                            context=None):
        """Invoke 'each' methods on `r`."""

        for a in dir(self):
            if a.startswith('each'):
                rdict = self._as_dict(r)
                f = getattr(self, a)
                try:
                    f(rdict)
                except Exception as e:
                    if report_unexpected_exceptions:
                        p = {'code': UNEXPECTED_EXCEPTION}
                        if not summarize:
                            p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                            p['row'] = i + 1
                            p['record'] = r
                            p['exception'] = e
                            p['function'] = '%s: %s' % (f.__name__,
                                                        f.__doc__)
                            if context is not None: p['context'] = context
                        yield p

def
_apply_each_methods
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
a
in
dir
(
self
)
:
if
a
.
startswith
(
'each'
)
:
rdict
=
self
.
_as_dict
(
r
)
f
=
getattr
(
self
,
a
)
try
:
f
(
rdict
)
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
f
.
__name__
,
f
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _apply_assert_methods(self, i, r,
                              summarize=False,
                              report_unexpected_exceptions=True,
                              context=None):
        """Apply 'assert' methods on `r`."""

        for a in dir(self):
            if a.startswith('assert'):
                rdict = self._as_dict(r)
                f = getattr(self, a)
                try:
                    f(rdict)
                except AssertionError as e:
                    code = ASSERT_CHECK_FAILED
                    message = MESSAGES[ASSERT_CHECK_FAILED]
                    if len(e.args) > 0:
                        custom = e.args[0]
                        if isinstance(custom, (list, tuple)):
                            if len(custom) > 0:
                                code = custom[0]
                            if len(custom) > 1:
                                message = custom[1]
                        else:
                            code = custom
                    p = {'code': code}
                    if not summarize:
                        p['message'] = message
                        p['row'] = i + 1
                        p['record'] = r
                        if context is not None: p['context'] = context
                    yield p
                except Exception as e:
                    if report_unexpected_exceptions:
                        p = {'code': UNEXPECTED_EXCEPTION}
                        if not summarize:
                            p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                            p['row'] = i + 1
                            p['record'] = r
                            p['exception'] = e
                            p['function'] = '%s: %s' % (f.__name__,
                                                        f.__doc__)
                            if context is not None: p['context'] = context
                        yield p

def
_apply_assert_methods
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
a
in
dir
(
self
)
:
if
a
.
startswith
(
'assert'
)
:
rdict
=
self
.
_as_dict
(
r
)
f
=
getattr
(
self
,
a
)
try
:
f
(
rdict
)
except
AssertionError
as
e
:
code
=
ASSERT_CHECK_FAILED
message
=
MESSAGES
[
ASSERT_CHECK_FAILED
]
if
len
(
e
.
args
)
>
0
:
custom
=
e
.
args
[
0
]
if
isinstance
(
custom
,
(
list
,
tuple
)
)
:
if
len
(
custom
)
>
0
:
code
=
custom
[
0
]
if
len
(
custom
)
>
1
:
message
=
custom
[
1
]
else
:
code
=
custom
p
=
{
'code'
:
code
}
if
not
summarize
:
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
if
context
is
not
:
p
[
'context'
]
=
context
yield
p
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
f
.
__name__
,
f
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _apply_check_methods(self, i, r,
                              summarize=False,
                              report_unexpected_exceptions=True,
                              context=None):
        """Apply 'check' methods on `r`."""

        for a in dir(self):
            if a.startswith('check'):
                rdict = self._as_dict(r)
                f = getattr(self, a)
                try:
                    f(rdict)
                except RecordError as e:
                    code = e.code if e.code is not None else RECORD_CHECK_FAILED
                    p = {'code': code}
                    if not summarize:
                        message = e.message if e.message is not None else MESSAGES[RECORD_CHECK_FAILED]
                        p['message'] = message
                        p['row'] = i + 1
                        p['record'] = r
                        if context is not None: p['context'] = context
                        if e.details is not None: p['details'] = e.details
                    yield p
                except Exception as e:
                    if report_unexpected_exceptions:
                        p = {'code': UNEXPECTED_EXCEPTION}
                        if not summarize:
                            p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                            p['row'] = i + 1
                            p['record'] = r
                            p['exception'] = e
                            p['function'] = '%s: %s' % (f.__name__,
                                                        f.__doc__)
                            if context is not None: p['context'] = context
                        yield p

def
_apply_check_methods
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
a
in
dir
(
self
)
:
if
a
.
startswith
(
'check'
)
:
rdict
=
self
.
_as_dict
(
r
)
f
=
getattr
(
self
,
a
)
try
:
f
(
rdict
)
except
RecordError
as
e
:
code
=
e
.
code
if
e
.
code
is
not
else
RECORD_CHECK_FAILED
p
=
{
'code'
:
code
}
if
not
summarize
:
message
=
e
.
message
if
e
.
message
is
not
else
MESSAGES
[
RECORD_CHECK_FAILED
]
p
[
'message'
]
=
message
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
if
context
is
not
:
p
[
'context'
]
=
context
if
e
.
details
is
not
:
p
[
'details'
]
=
e
.
details
yield
p
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
f
.
__name__
,
f
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _apply_skips(self, i, r,
                     summarize=False,
                     report_unexpected_exceptions=True,
                     context=None):
        """Apply skip functions on `r`."""

        for skip in self._skips:
            try:
                result = skip(r)
                if result is True:
                    yield True
            except Exception as e:
                if report_unexpected_exceptions:
                    p = {'code': UNEXPECTED_EXCEPTION}
                    if not summarize:
                        p['message'] = MESSAGES[UNEXPECTED_EXCEPTION] % (e.__class__.__name__, e)
                        p['row'] = i + 1
                        p['record'] = r
                        p['exception'] = e
                        p['function'] = '%s: %s' % (skip.__name__,
                                                    skip.__doc__)
                        if context is not None: p['context'] = context
                    yield p

def
_apply_skips
(
self
,
i
,
r
,
summarize
=
False
,
report_unexpected_exceptions
=
True
,
context
=
)
:
for
skip
in
self
.
_skips
:
try
:
result
=
skip
(
r
)
if
result
is
True
:
yield
True
except
Exception
as
e
:
if
report_unexpected_exceptions
:
p
=
{
'code'
:
UNEXPECTED_EXCEPTION
}
if
not
summarize
:
p
[
'message'
]
=
MESSAGES
[
UNEXPECTED_EXCEPTION
]
%
(
e
.
__class__
.
__name__
,
e
)
p
[
'row'
]
=
i
+
1
p
[
'record'
]
=
r
p
[
'exception'
]
=
e
p
[
'function'
]
=
'%s: %s'
%
(
skip
.
__name__
,
skip
.
__doc__
)
if
context
is
not
:
p
[
'context'
]
=
context
yield
p


def _as_dict(self, r):
        """Convert the record to a dictionary using field names as keys."""

        d = dict()
        for i, f in enumerate(self._field_names):
            d[f] = r[i] if i < len(r) else None
        return d

def _as_dict ( self , r ) : d = dict ( ) for i , f in enumerate ( self . _field_names ) : d [ f ] = r [ i ] if i < len ( r ) else None return d

Convert the record to a dictionary using field names as keys .


def create_validator():
    """Create an example CSV validator for patient demographic data."""

    field_names = (
                   'study_id',
                   'patient_id',
                   'gender',
                   'age_years',
                   'age_months',
                   'date_inclusion'
                   )
    validator = CSVValidator(field_names)

    # basic header and record length checks
    validator.add_header_check('EX1', 'bad header')
    validator.add_record_length_check('EX2', 'unexpected record length')

    # some simple value checks
    validator.add_value_check('study_id', int,
                              'EX3', 'study id must be an integer')
    validator.add_value_check('patient_id', int,
                              'EX4', 'patient id must be an integer')
    validator.add_value_check('gender', enumeration('M', 'F'),
                              'EX5', 'invalid gender')
    validator.add_value_check('age_years', number_range_inclusive(0, 120, int),
                              'EX6', 'invalid age in years')
    validator.add_value_check('date_inclusion', datetime_string('%Y-%m-%d'),
                              'EX7', 'invalid date')

    # a more complicated record check
    def check_age_variables(r):
        age_years = int(r['age_years'])
        age_months = int(r['age_months'])
        valid = (age_months >= age_years * 12 and
                 age_months % age_years < 12)
        if not valid:
            raise RecordError('EX8', 'invalid age variables')
    validator.add_record_check(check_age_variables)

    return validator

def
create_validator
(
)
:
field_names
=
(
'study_id'
,
'patient_id'
,
'gender'
,
'age_years'
,
'age_months'
,
'date_inclusion'
)
validator
=
CSVValidator
(
field_names
)
# basic header and record length checks
validator
.
add_header_check
(
'EX1'
,
'bad header'
)
validator
.
add_record_length_check
(
'EX2'
,
'unexpected record length'
)
# some simple value checks
validator
.
add_value_check
(
'study_id'
,
int
,
'EX3'
,
'study id must be an integer'
)
validator
.
add_value_check
(
'patient_id'
,
int
,
'EX4'
,
'patient id must be an integer'
)
validator
.
add_value_check
(
'gender'
,
enumeration
(
'M'
,
'F'
)
,
'EX5'
,
'invalid gender'
)
validator
.
add_value_check
(
'age_years'
,
number_range_inclusive
(
0
,
120
,
int
)
,
'EX6'
,
'invalid age in years'
)
validator
.
add_value_check
(
'date_inclusion'
,
datetime_string
(
'%Y-%m-%d'
)
,
'EX7'
,
'invalid date'
)
# a more complicated record check
def
check_age_variables
(
r
)
:
age_years
=
int
(
r
[
'age_years'
]
)
age_months
=
int
(
r
[
'age_months'
]
)
valid
=
(
age_months
>=
age_years
*
12
and
age_months
%
age_years
<
12
)
if
not
valid
:
raise
RecordError
(
'EX8'
,
'invalid age variables'
)
validator
.
add_record_check
(
check_age_variables
)
return
validator

Create an example CSV validator for patient demographic data .


def main():
    """Main function."""

    # define a command-line argument parser
    description = 'Validate a CSV data file.'
    parser = argparse.ArgumentParser(description=description)
    parser.add_argument('file',
                        metavar='FILE',
                        help='a file to be validated')
    parser.add_argument('-l', '--limit',
                        dest='limit',
                        type=int,
                        action='store',
                        default=0,
                        help='limit the number of problems reported'
                        )
    parser.add_argument('-s', '--summarize',
                        dest='summarize',
                        action='store_true',
                        default=False,
                        help='output only a summary of the different types of problem found'
                        )
    parser.add_argument('-e', '--report-unexpected-exceptions',
                        dest='report_unexpected_exceptions',
                        action='store_true',
                        default=False,
                        help='report any unexpected exceptions as problems'
                        )

    # parse arguments
    args = parser.parse_args()

    # sanity check arguments
    if not os.path.isfile(args.file):
        print '%s is not a file' % args.file
        sys.exit(1)

    with open(args.file, 'r') as f:

        # set up a csv reader for the data
        data = csv.reader(f, delimiter='\t')

        # create a validator
        validator = create_validator()

        # validate the data from the csv reader
        # N.B., validate() returns a list of problems;
        # if you expect a large number of problems, use ivalidate() instead
        # of validate(), but bear in mind that ivalidate() returns an iterator
        # so there is no len()
        problems = validator.validate(data,
                                      summarize=args.summarize,
                                      report_unexpected_exceptions=args.report_unexpected_exceptions,
                                      context={'file': args.file})

        # write problems to stdout as restructured text
        write_problems(problems, sys.stdout,
                       summarize=args.summarize,
                       limit=args.limit)

        # decide how to exit
        if problems: # will not work with ivalidate() because it returns an iterator
            sys.exit(1)
        else:
            sys.exit(0)


def pack_into(fmt, buf, offset, *args, **kwargs):
    """Pack given values v1, v2, ... into given bytearray `buf`, starting
    at given bit offset `offset`. Pack according to given format
    string `fmt`. Give `fill_padding` as ``False`` to leave padding
    bits in `buf` unmodified.

    """

    return CompiledFormat(fmt).pack_into(buf,
                                         offset,
                                         *args,
                                         **kwargs)

def pack_into ( fmt , buf , offset , * args , * * kwargs ) : return CompiledFormat ( fmt ) . pack_into ( buf , offset , * args , * * kwargs )

Pack given values v1 v2 ... into given bytearray buf starting at given bit offset offset . Pack according to given format string fmt . Give fill_padding as False to leave padding bits in buf unmodified .


def byteswap(fmt, data, offset=0):
    """Swap bytes in `data` according to `fmt`, starting at byte `offset`
    and return the result. `fmt` must be an iterable, iterating over
    number of bytes to swap. For example, the format string ``'24'``
    applied to the bytes ``b'\\x00\\x11\\x22\\x33\\x44\\x55'`` will
    produce the result ``b'\\x11\\x00\\x55\\x44\\x33\\x22'``.

    """

    data = BytesIO(data)
    data.seek(offset)
    data_swapped = BytesIO()

    for f in fmt:
        swapped = data.read(int(f))[::-1]
        data_swapped.write(swapped)

    return data_swapped.getvalue()

def byteswap ( fmt , data , offset = 0 ) : data = BytesIO ( data ) data . seek ( offset ) data_swapped = BytesIO ( ) for f in fmt : swapped = data . read ( int ( f ) ) [ : : - 1 ] data_swapped . write ( swapped ) return data_swapped . getvalue ( )


def get_chat_id(self, message):
        '''
        Telegram chat type can be either "private", "group", "supergroup" or
        "channel".
        Return user ID if it is of type "private", chat ID otherwise.
        '''
        if message.chat.type == 'private':
            return message.user.id

        return message.chat.id

def get_chat_id ( self , message ) : if message . chat . type == 'private' : return message . user . id return message . chat . id

Telegram chat type can be either private group supergroup or channel . Return user ID if it is of type private chat ID otherwise .


def build_message(self, data):
        '''
        Return a Message instance according to the data received from
        Facebook Messenger API.
        '''
        if not data:
            return None

        return Message(
            id=data['message']['mid'],
            platform=self.platform,
            text=data['message']['text'],
            user=data['sender']['id'],
            timestamp=data['timestamp'],
            raw=data,
            chat=None,  # TODO: Refactor build_messages and Message class
        )

Return a Message instance according to the data received from Facebook Messenger API .


async def _get_response(self, message):
        """
        Get response running the view with await syntax if it is a
        coroutine function, otherwise just run it the normal way.
        """

        view = self.discovery_view(message)
        if not view:
            return

        if inspect.iscoroutinefunction(view):
            response = await view(message)
        else:
            response = view(message)

        return self.prepare_response(response, message)

async def _get_response ( self , message ) : view = self . discovery_view ( message ) if not view : return if inspect . iscoroutinefunction ( view ) : response = await view ( message ) else : response = view ( message ) return self . prepare_response ( response , message )

Get response running the view with await syntax if it is a coroutine function otherwise just run it the normal way .


def discovery_view(self, message):
        """
        Use the new message to search for a registered view according
        to its pattern.
        """
        for handler in self.registered_handlers:
            if handler.check(message):
                return handler.view

        return None

def discovery_view ( self , message ) : for handler in self . registered_handlers : if handler . check ( message ) : return handler . view return None

Use the new message to search for a registered view according to its pattern .


async def message_handler(self, data):
        """
        For each new message, build its platform specific message
        object and get a response.
        """

        message = self.build_message(data)
        if not message:
            logger.error(
                '[%s] Unable to build Message with data, data=%s, error',
                self.engine_name,
                data
            )
            return

        logger.info('[%s] New message from %s: %s', self.engine_name,
                    message.user, message.text)

        response = await self.get_response(message)
        if response:
            await self.send_response(response)

For each new message build its platform specific message object and get a response .


def unpack(endian, fmt, data):
    """Unpack a byte string to the given format. If the byte string
    contains more bytes than required for the given format, the function
    returns a tuple of values.
    """
    if fmt == 's':
        # read data as an array of chars
        val = struct.unpack(''.join([endian, str(len(data)), 's']),
                            data)[0]
    else:
        # read a number of values
        num = len(data) // struct.calcsize(fmt)
        val = struct.unpack(''.join([endian, str(num), fmt]), data)
        if len(val) == 1:
            val = val[0]
    return val

def
unpack
(
endian
,
fmt
,
data
)
:
if
fmt
==
's'
:
# read data as an array of chars
val
=
struct
.
unpack
(
''
.
join
(
[
endian
,
str
(
len
(
data
)
)
,
's'
]
)
,
data
)
[
0
]
else
:
# read a number of values
num
=
len
(
data
)
//
struct
.
calcsize
(
fmt
)
val
=
struct
.
unpack
(
''
.
join
(
[
endian
,
str
(
num
)
,
fmt
]
)
,
data
)
if
len
(
val
)
==
1
:
val
=
val
[
0
]
return
val

Unpack a byte string to the given format . If the byte string contains more bytes than required for the given format the function returns a tuple of values .


def read_file_header(fd, endian):
    """Read mat 5 file header of the file fd.
    Returns a dict with header values.
    """
    fields = [
        ('description', 's', 116),
        ('subsystem_offset', 's', 8),
        ('version', 'H', 2),
        ('endian_test', 's', 2)
    ]
    hdict = {}
    for name, fmt, num_bytes in fields:
        data = fd.read(num_bytes)
        hdict[name] = unpack(endian, fmt, data)
    hdict['description'] = hdict['description'].strip()
    v_major = hdict['version'] >> 8
    v_minor = hdict['version'] & 0xFF
    hdict['__version__'] = '%d.%d' % (v_major, v_minor)
    return hdict

def read_file_header ( fd , endian ) : fields = [ ( 'description' , 's' , 116 ) , ( 'subsystem_offset' , 's' , 8 ) , ( 'version' , 'H' , 2 ) , ( 'endian_test' , 's' , 2 ) ] hdict = { } for name , fmt , num_bytes in fields : data = fd . read ( num_bytes ) hdict [ name ] = unpack ( endian , fmt , data ) hdict [ 'description' ] = hdict [ 'description' ] . strip ( ) v_major = hdict [ 'version' ] >> 8 v_minor = hdict [ 'version' ] & 0xFF hdict [ '__version__' ] = '%d.%d' % ( v_major , v_minor ) return hdict

Read mat 5 file header of the file fd . Returns a dict with header values .


def read_elements(fd, endian, mtps, is_name=False):
    """Read elements from the file.

    If list of possible matrix data types mtps is provided, the data type
    of the elements are verified.
    """
    mtpn, num_bytes, data = read_element_tag(fd, endian)
    if mtps and mtpn not in [etypes[mtp]['n'] for mtp in mtps]:
        raise ParseError('Got type {}, expected {}'.format(
            mtpn, ' / '.join('{} ({})'.format(
                etypes[mtp]['n'], mtp) for mtp in mtps)))
    if not data:
        # full format, read data
        data = fd.read(num_bytes)
        # Seek to next 64-bit boundary
        mod8 = num_bytes % 8
        if mod8:
            fd.seek(8 - mod8, 1)

    # parse data and return values
    if is_name:
        # names are stored as miINT8 bytes
        fmt = 's'
        val = [unpack(endian, fmt, s)
               for s in data.split(b'\0') if s]
        if len(val) == 0:
            val = ''
        elif len(val) == 1:
            val = asstr(val[0])
        else:
            val = [asstr(s) for s in val]
    else:
        fmt = etypes[inv_etypes[mtpn]]['fmt']
        val = unpack(endian, fmt, data)
    return val

def
read_elements
(
fd
,
endian
,
mtps
,
is_name
=
False
)
:
mtpn
,
num_bytes
,
data
=
read_element_tag
(
fd
,
endian
)
if
mtps
and
mtpn
not
in
[
etypes
[
mtp
]
[
'n'
]
for
mtp
in
mtps
]
:
raise
ParseError
(
'Got type {}, expected {}'
.
format
(
mtpn
,
' / '
.
join
(
'{} ({})'
.
format
(
etypes
[
mtp
]
[
'n'
]
,
mtp
)
for
mtp
in
mtps
)
)
)
if
not
data
:
# full format, read data
data
=
fd
.
read
(
num_bytes
)
# Seek to next 64-bit boundary
mod8
=
num_bytes
%
8
if
mod8
:
fd
.
seek
(
8
mod8
,
1
)
# parse data and return values
if
is_name
:
# names are stored as miINT8 bytes
fmt
=
's'
val
=
[
unpack
(
endian
,
fmt
,
s
)
for
s
in
data
.
split
(
b'\0'
)
if
s
]
if
len
(
val
)
==
0
:
val
=
''
elif
len
(
val
)
==
1
:
val
=
asstr
(
val
[
0
]
)
else
:
val
=
[
asstr
(
s
)
for
s
in
val
]
else
:
fmt
=
etypes
[
inv_etypes
[
mtpn
]
]
[
'fmt'
]
val
=
unpack
(
endian
,
fmt
,
data
)
return
val


def read_header(fd, endian):
    """Read and return the matrix header."""
    flag_class, nzmax = read_elements(fd, endian, ['miUINT32'])
    header = {
        'mclass': flag_class & 0x0FF,
        'is_logical': (flag_class >> 9 & 1) == 1,
        'is_global': (flag_class >> 10 & 1) == 1,
        'is_complex': (flag_class >> 11 & 1) == 1,
        'nzmax': nzmax
    }
    header['dims'] = read_elements(fd, endian, ['miINT32'])
    header['n_dims'] = len(header['dims'])
    if header['n_dims'] != 2:
        raise ParseError('Only matrices with dimension 2 are supported.')
    header['name'] = read_elements(fd, endian, ['miINT8'], is_name=True)
    return header


def read_var_header(fd, endian):
    """Read full header tag.

    Return a dict with the parsed header, the file position of next tag,
    a file like object for reading the uncompressed element data.
    """
    mtpn, num_bytes = unpack(endian, 'II', fd.read(8))
    next_pos = fd.tell() + num_bytes

    if mtpn == etypes['miCOMPRESSED']['n']:
        # read compressed data
        data = fd.read(num_bytes)
        dcor = zlib.decompressobj()
        # from here, read of the decompressed data
        fd_var = BytesIO(dcor.decompress(data))
        del data
        fd = fd_var
        # Check the stream is not so broken as to leave cruft behind
        if dcor.flush() != b'':
            raise ParseError('Error in compressed data.')
        # read full tag from the uncompressed data
        mtpn, num_bytes = unpack(endian, 'II', fd.read(8))

    if mtpn != etypes['miMATRIX']['n']:
        raise ParseError('Expecting miMATRIX type number {}, '
                         'got {}'.format(etypes['miMATRIX']['n'], mtpn))
    # read the header
    header = read_header(fd, endian)
    return header, next_pos, fd


def read_numeric_array(fd, endian, header, data_etypes):
    """Read a numeric matrix.
    Returns an array with rows of the numeric matrix.
    """
    if header['is_complex']:
        raise ParseError('Complex arrays are not supported')
    # read array data (stored as column-major)
    data = read_elements(fd, endian, data_etypes)
    if not isinstance(data, Sequence):
        # not an array, just a value
        return data
    # transform column major data continous array to
    # a row major array of nested lists
    rowcount = header['dims'][0]
    colcount = header['dims'][1]
    array = [list(data[c * rowcount + r] for c in range(colcount))
             for r in range(rowcount)]
    # pack and return the array
    return squeeze(array)

Read a numeric matrix . Returns an array with rows of the numeric matrix .


def read_cell_array(fd, endian, header):
    """Read a cell array.
    Returns an array with rows of the cell array.
    """
    array = [list() for i in range(header['dims'][0])]
    for row in range(header['dims'][0]):
        for col in range(header['dims'][1]):
            # read the matrix header and array
            vheader, next_pos, fd_var = read_var_header(fd, endian)
            varray = read_var_array(fd_var, endian, vheader)
            array[row].append(varray)
            # move on to next field
            fd.seek(next_pos)
    # pack and return the array
    if header['dims'][0] == 1:
        return squeeze(array[0])
    return squeeze(array)

def
read_cell_array
(
fd
,
endian
,
header
)
:
array
=
[
list
(
)
for
i
in
range
(
header
[
'dims'
]
[
0
]
)
]
for
row
in
range
(
header
[
'dims'
]
[
0
]
)
:
for
col
in
range
(
header
[
'dims'
]
[
1
]
)
:
# read the matrix header and array
vheader
,
next_pos
,
fd_var
=
read_var_header
(
fd
,
endian
)
varray
=
read_var_array
(
fd_var
,
endian
,
vheader
)
array
[
row
]
.
append
(
varray
)
# move on to next field
fd
.
seek
(
next_pos
)
# pack and return the array
if
header
[
'dims'
]
[
0
]
==
1
:
return
squeeze
(
array
[
0
]
)
return
squeeze
(
array
)

Read a cell array . Returns an array with rows of the cell array .


def read_struct_array(fd, endian, header):
    """Read a struct array.
    Returns a dict with fields of the struct array.
    """
    # read field name length (unused, as strings are null terminated)
    field_name_length = read_elements(fd, endian, ['miINT32'])
    if field_name_length > 32:
        raise ParseError('Unexpected field name length: {}'.format(
                         field_name_length))

    # read field names
    fields = read_elements(fd, endian, ['miINT8'], is_name=True)
    if isinstance(fields, basestring):
        fields = [fields]

    # read rows and columns of each field
    empty = lambda: [list() for i in range(header['dims'][0])]
    array = {}
    for row in range(header['dims'][0]):
        for col in range(header['dims'][1]):
            for field in fields:
                # read the matrix header and array
                vheader, next_pos, fd_var = read_var_header(fd, endian)
                data = read_var_array(fd_var, endian, vheader)
                if field not in array:
                    array[field] = empty()
                array[field][row].append(data)
                # move on to next field
                fd.seek(next_pos)
    # pack the nested arrays
    for field in fields:
        rows = array[field]
        for i in range(header['dims'][0]):
            rows[i] = squeeze(rows[i])
        array[field] = squeeze(array[field])
    return array

Read a struct array . Returns a dict with fields of the struct array .


def eof(fd):
    """Determine if end-of-file is reached for file fd."""
    b = fd.read(1)
    end = len(b) == 0
    if not end:
        curpos = fd.tell()
        fd.seek(curpos - 1)
    return end

def eof ( fd ) : b = fd . read ( 1 ) end = len ( b ) == 0 if not end : curpos = fd . tell ( ) fd . seek ( curpos - 1 ) return end

Determine if end - of - file is reached for file fd .


def write_elements(fd, mtp, data, is_name=False):
    """Write data element tag and data.

    The tag contains the array type and the number of
    bytes the array data will occupy when written to file.

    If data occupies 4 bytes or less, it is written immediately
    as a Small Data Element (SDE).
    """
    fmt = etypes[mtp]['fmt']
    if isinstance(data, Sequence):
        if fmt == 's' or is_name:
            if isinstance(data, bytes):
                if is_name and len(data) > 31:
                    raise ValueError(
                        'Name "{}" is too long (max. 31 '
                        'characters allowed)'.format(data))
                fmt = '{}s'.format(len(data))
                data = (data,)
            else:
                fmt = ''.join('{}s'.format(len(s)) for s in data)
        else:
            l = len(data)
            if l == 0:
                # empty array
                fmt = ''
            if l > 1:
                # more than one element to be written
                fmt = '{}{}'.format(l, fmt)
    else:
        data = (data,)
    num_bytes = struct.calcsize(fmt)
    if num_bytes <= 4:
        # write SDE
        if num_bytes < 4:
            # add pad bytes
            fmt += '{}x'.format(4 - num_bytes)
        fd.write(struct.pack('hh' + fmt, etypes[mtp]['n'],
                 *chain([num_bytes], data)))
        return
    # write tag: element type and number of bytes
    fd.write(struct.pack('b3xI', etypes[mtp]['n'], num_bytes))
    # add pad bytes to fmt, if needed
    mod8 = num_bytes % 8
    if mod8:
        fmt += '{}x'.format(8 - mod8)
    # write data
    fd.write(struct.pack(fmt, *data))


def write_var_header(fd, header):
    """Write variable header"""

    # write tag bytes,
    # and array flags + class and nzmax (null bytes)
    fd.write(struct.pack('b3xI', etypes['miUINT32']['n'], 8))
    fd.write(struct.pack('b3x4x', mclasses[header['mclass']]))

    # write dimensions array
    write_elements(fd, 'miINT32', header['dims'])

    # write var name
    write_elements(fd, 'miINT8', asbytes(header['name']), is_name=True)


def write_var_data(fd, data):
    """Write variable data to file"""
    # write array data elements (size info)
    fd.write(struct.pack('b3xI', etypes['miMATRIX']['n'], len(data)))

    # write the data
    fd.write(data)

def
write_var_data
(
fd
,
data
)
:
# write array data elements (size info)
fd
.
write
(
struct
.
pack
(
'b3xI'
,
etypes
[
'miMATRIX'
]
[
'n'
]
,
len
(
data
)
)
)
# write the data
fd
.
write
(
data
)


def write_compressed_var_array(fd, array, name):
    """Write compressed variable data to file"""
    bd = BytesIO()

    write_var_array(bd, array, name)

    data = zlib.compress(bd.getvalue())
    bd.close()

    # write array data elements (size info)
    fd.write(struct.pack('b3xI', etypes['miCOMPRESSED']['n'], len(data)))

    # write the compressed data
    fd.write(data)

def
write_compressed_var_array
(
fd
,
array
,
name
)
:
bd
=
BytesIO
(
)
write_var_array
(
bd
,
array
,
name
)
data
=
zlib
.
compress
(
bd
.
getvalue
(
)
)
bd
.
close
(
)
# write array data elements (size info)
fd
.
write
(
struct
.
pack
(
'b3xI'
,
etypes
[
'miCOMPRESSED'
]
[
'n'
]
,
len
(
data
)
)
)
# write the compressed data
fd
.
write
(
data
)


def write_numeric_array(fd, header, array):
    """Write the numeric array"""
    # make a memory file for writing array data
    bd = BytesIO()

    # write matrix header to memory file
    write_var_header(bd, header)

    if not isinstance(array, basestring) and header['dims'][0] > 1:
        # list array data in column major order
        array = list(chain.from_iterable(izip(*array)))

    # write matrix data to memory file
    write_elements(bd, header['mtp'], array)

    # write the variable to disk file
    data = bd.getvalue()
    bd.close()
    write_var_data(fd, data)


def isarray(array, test, dim=2):
    """Returns True if test is True for all array elements.
    Otherwise, returns False.
    """
    if dim > 1:
        return all(isarray(array[i], test, dim - 1)
                   for i in range(len(array)))
    return all(test(i) for i in array)

def isarray ( array , test , dim = 2 ) : if dim > 1 : return all ( isarray ( array [ i ] , test , dim - 1 ) for i in range ( len ( array ) ) ) return all ( test ( i ) for i in array )

Returns True if test is True for all array elements . Otherwise returns False .


def _execute(self, command, data=None, unpack=True):
        """ Private method to execute command.

        Args:
            command(Command): The defined command.
            data(dict): The uri variable and body.
            uppack(bool): If unpack value from result.

        Returns:
            The unwrapped value field in the json response.
        """
        if not data:
            data = {}
        if self.session_id is not None:
            data.setdefault('session_id', self.session_id)
        data = self._wrap_el(data)
        res = self.remote_invoker.execute(command, data)
        ret = WebDriverResult.from_object(res)
        ret.raise_for_status()
        ret.value = self._unwrap_el(ret.value)
        if not unpack:
            return ret
        return ret.value

def _execute ( self , command , data = None , unpack = True ) : if not data : data = { } if self . session_id is not None : data . setdefault ( 'session_id' , self . session_id ) data = self . _wrap_el ( data ) res = self . remote_invoker . execute ( command , data ) ret = WebDriverResult . from_object ( res ) ret . raise_for_status ( ) ret . value = self . _unwrap_el ( ret . value ) if not unpack : return ret return ret . value


def init(self):
        """Create Session by desiredCapabilities

        Support:
            Android iOS Web(WebView)

        Returns:
            WebDriver Object.
        """
        resp = self._execute(Command.NEW_SESSION, {
            'desiredCapabilities': self.desired_capabilities
        }, False)
        resp.raise_for_status()
        self.session_id = str(resp.session_id)
        self.capabilities = resp.value

def init ( self ) : resp = self . _execute ( Command . NEW_SESSION , { 'desiredCapabilities' : self . desired_capabilities } , False ) resp . raise_for_status ( ) self . session_id = str ( resp . session_id ) self . capabilities = resp . value


def switch_to_window(self, window_name):
        """Switch to the given window.

        Support:
            Web(WebView)

        Args:
            window_name(str): The window to change focus to.

        Returns:
            WebDriver Object.
        """
        data = {
            'name': window_name
        }
        self._execute(Command.SWITCH_TO_WINDOW, data)

def switch_to_window ( self , window_name ) : data = { 'name' : window_name } self . _execute ( Command . SWITCH_TO_WINDOW , data )


def set_window_size(self, width, height, window_handle='current'):
        """Sets the width and height of the current window.

        Support:
            Web(WebView)

        Args:
            width(int): the width in pixels.
            height(int): the height in pixels.
            window_handle(str): Identifier of window_handle,
                default to 'current'.

        Returns:
            WebDriver Object.
        """
        self._execute(Command.SET_WINDOW_SIZE, {
            'width': int(width),
            'height': int(height),
            'window_handle': window_handle})

def set_window_size ( self , width , height , window_handle = 'current' ) : self . _execute ( Command . SET_WINDOW_SIZE , { 'width' : int ( width ) , 'height' : int ( height ) , 'window_handle' : window_handle } )

Sets the width and height of the current window .


def set_window_position(self, x, y, window_handle='current'):
        """Sets the x,y position of the current window.

        Support:
            Web(WebView)

        Args:
            x(int): the x-coordinate in pixels.
            y(int): the y-coordinate in pixels.
            window_handle(str): Identifier of window_handle,
                default to 'current'.

        Returns:
            WebDriver Object.
        """
        self._execute(Command.SET_WINDOW_POSITION, {
            'x': int(x),
            'y': int(y),
            'window_handle': window_handle})

def set_window_position ( self , x , y , window_handle = 'current' ) : self . _execute ( Command . SET_WINDOW_POSITION , { 'x' : int ( x ) , 'y' : int ( y ) , 'window_handle' : window_handle } )

Sets the x y position of the current window .


def switch_to_frame(self, frame_reference=None):
        """Switches focus to the specified frame, by index, name, or webelement.

        Support:
            Web(WebView)

        Args:
            frame_reference(None|int|WebElement):
                The identifier of the frame to switch to.
                None means to set to the default context.
                An integer representing the index.
                A webelement means that is an (i)frame to switch to.
                Otherwise throw an error.

        Returns:
            WebDriver Object.
        """
        if frame_reference is not None and type(frame_reference) not in [int, WebElement]:
            raise TypeError('Type of frame_reference must be None or int or WebElement')
        self._execute(Command.SWITCH_TO_FRAME,
            {'id': frame_reference})

Switches focus to the specified frame by index name or webelement .


def execute_script(self, script, *args):
        """Execute JavaScript Synchronously in current context.

        Support:
            Web(WebView)

        Args:
            script: The JavaScript to execute.
            *args: Arguments for your JavaScript.

        Returns:
            Returns the return value of the function.
        """
        return self._execute(Command.EXECUTE_SCRIPT, {
            'script': script,
            'args': list(args)})

def execute_script ( self , script , * args ) : return self . _execute ( Command . EXECUTE_SCRIPT , { 'script' : script , 'args' : list ( args ) } )

Execute JavaScript Synchronously in current context .


def execute_async_script(self, script, *args):
        """Execute JavaScript Asynchronously in current context.

        Support:
            Web(WebView)

        Args:
            script: The JavaScript to execute.
            *args: Arguments for your JavaScript.

        Returns:
            Returns the return value of the function.
        """
        return self._execute(Command.EXECUTE_ASYNC_SCRIPT, {
            'script': script,
            'args': list(args)})

def execute_async_script ( self , script , * args ) : return self . _execute ( Command . EXECUTE_ASYNC_SCRIPT , { 'script' : script , 'args' : list ( args ) } )

Execute JavaScript Asynchronously in current context .


def add_cookie(self, cookie_dict):
        """Set a cookie.

        Support:
            Web(WebView)

        Args:
            cookie_dict: A dictionary contain keys: "name", "value",
                ["path"], ["domain"], ["secure"], ["httpOnly"], ["expiry"].

        Returns:
            WebElement Object.
        """
        if not isinstance(cookie_dict, dict):
            raise TypeError('Type of the cookie must be a dict.')
        if not cookie_dict.get(
            'name', None
        ) or not cookie_dict.get(
            'value', None):
            raise KeyError('Missing required keys, \'name\' and \'value\' must be provided.')
        self._execute(Command.ADD_COOKIE, {'cookie': cookie_dict})


def save_screenshot(self, filename, quietly = False):
        """Save the screenshot to local.

        Support:
            Android iOS Web(WebView)

        Args:
            filename(str): The path to save the image.
            quietly(bool): If True, omit the IOError when
                failed to save the image.

        Returns:
            WebElement Object.

        Raises:
            WebDriverException.
            IOError.
        """
        imgData = self.take_screenshot()
        try:
            with open(filename, "wb") as f:
                f.write(b64decode(imgData.encode('ascii')))
        except IOError as err:
            if not quietly:
                raise err

def save_screenshot ( self , filename , quietly = False ) : imgData = self . take_screenshot ( ) try : with open ( filename , "wb" ) as f : f . write ( b64decode ( imgData . encode ( 'ascii' ) ) ) except IOError as err : if not quietly : raise err


def element(self, using, value):
        """Find an element in the current context.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            WebElement Object.

        Raises:
            WebDriverException.
        """
        return self._execute(Command.FIND_ELEMENT, {
            'using': using,
            'value': value
        })

def element ( self , using , value ) : return self . _execute ( Command . FIND_ELEMENT , { 'using' : using , 'value' : value } )

Find an element in the current context .


def elements(self, using, value):
        """Find elements in the current context.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            Return a List<Element | None>, if no element matched, the list is empty.

        Raises:
            WebDriverException.
        """
        return self._execute(Command.FIND_ELEMENTS, {
            'using': using,
            'value': value
        })

def elements ( self , using , value ) : return self . _execute ( Command . FIND_ELEMENTS , { 'using' : using , 'value' : value } )


def wait_for(
        self, timeout=10000, interval=1000,
        asserter=lambda x: x):
        """Wait for driver till satisfy the given condition

        Support:
            Android iOS Web(WebView)

        Args:
            timeout(int): How long we should be retrying stuff.
            interval(int): How long between retries.
            asserter(callable): The asserter func to determine the result.

        Returns:
            Return the driver.

        Raises:
            WebDriverException.
        """
        if not callable(asserter):
            raise TypeError('Asserter must be callable.')
        @retry(
            retry_on_exception=lambda ex: isinstance(ex, WebDriverException),
            stop_max_delay=timeout,
            wait_fixed=interval
        )
        def _wait_for(driver):
            asserter(driver)
            return driver

        return _wait_for(self)

def
wait_for
(
self
,
timeout
=
10000
,
interval
=
1000
,
asserter
=
lambda
x
:
x
)
:
if
not
callable
(
asserter
)
:
raise
TypeError
(
'Asserter must be callable.'
)
@
retry
(
retry_on_exception
=
lambda
ex
:
isinstance
(
ex
,
WebDriverException
)
,
stop_max_delay
=
timeout
,
wait_fixed
=
interval
)
def
_wait_for
(
driver
)
:
asserter
(
driver
)
return
driver
return
_wait_for
(
self
)


def wait_for_element(
        self, using, value, timeout=10000,
        interval=1000, asserter=is_displayed):
        """Wait for element till satisfy the given condition

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.
            timeout(int): How long we should be retrying stuff.
            interval(int): How long between retries.
            asserter(callable): The asserter func to determine the result.

        Returns:
            Return the Element.

        Raises:
            WebDriverException.
        """
        if not callable(asserter):
            raise TypeError('Asserter must be callable.')
        @retry(
            retry_on_exception=lambda ex: isinstance(ex, WebDriverException),
            stop_max_delay=timeout,
            wait_fixed=interval
        )
        def _wait_for_element(ctx, using, value):
            el = ctx.element(using, value)
            asserter(el)
            return el

        return _wait_for_element(self, using, value)

def
wait_for_element
(
self
,
using
,
value
,
timeout
=
10000
,
interval
=
1000
,
asserter
=
is_displayed
)
:
if
not
callable
(
asserter
)
:
raise
TypeError
(
'Asserter must be callable.'
)
@
retry
(
retry_on_exception
=
lambda
ex
:
isinstance
(
ex
,
WebDriverException
)
,
stop_max_delay
=
timeout
,
wait_fixed
=
interval
)
def
_wait_for_element
(
ctx
,
using
,
value
)
:
el
=
ctx
.
element
(
using
,
value
)
asserter
(
el
)
return
el
return
_wait_for_element
(
self
,
using
,
value
)


def wait_for_elements(
        self, using, value, timeout=10000,
        interval=1000, asserter=is_displayed):
        """Wait for elements till satisfy the given condition

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.
            timeout(int): How long we should be retrying stuff.
            interval(int): How long between retries.
            asserter(callable): The asserter func to determine the result.

        Returns:
            Return the list of Element if any of them satisfy the condition.

        Raises:
            WebDriverException.
        """
        if not callable(asserter):
            raise TypeError('Asserter must be callable.')
        @retry(
            retry_on_exception=lambda ex: isinstance(ex, WebDriverException),
            stop_max_delay=timeout,
            wait_fixed=interval
        )
        def _wait_for_elements(ctx, using, value):
            els = ctx.elements(using, value)
            if not len(els):
                raise WebDriverException('no such element')
            else:
                el = els[0]
                asserter(el)
                return els

        return _wait_for_elements(self, using, value)

def
wait_for_elements
(
self
,
using
,
value
,
timeout
=
10000
,
interval
=
1000
,
asserter
=
is_displayed
)
:
if
not
callable
(
asserter
)
:
raise
TypeError
(
'Asserter must be callable.'
)
@
retry
(
retry_on_exception
=
lambda
ex
:
isinstance
(
ex
,
WebDriverException
)
,
stop_max_delay
=
timeout
,
wait_fixed
=
interval
)
def
_wait_for_elements
(
ctx
,
using
,
value
)
:
els
=
ctx
.
elements
(
using
,
value
)
if
not
len
(
els
)
:
raise
WebDriverException
(
'no such element'
)
else
:
el
=
els
[
0
]
asserter
(
el
)
return
els
return
_wait_for_elements
(
self
,
using
,
value
)


def from_object(cls, obj):
        """The factory method to create WebDriverResult from JSON Object.

        Args:
            obj(dict): The JSON Object returned by server.
        """
        return cls(
            obj.get('sessionId', None),
            obj.get('status', 0),
            obj.get('value', None)
        )

def from_object ( cls , obj ) : return cls ( obj . get ( 'sessionId' , None ) , obj . get ( 'status' , 0 ) , obj . get ( 'value' , None ) )

The factory method to create WebDriverResult from JSON Object .


def raise_for_status(self):
        """Raise WebDriverException if returned status is not zero."""
        if not self.status:
            return

        error = find_exception_by_code(self.status)
        message = None
        screen = None
        stacktrace = None

        if isinstance(self.value, str):
            message = self.value
        elif isinstance(self.value, dict):
            message = self.value.get('message', None)
            screen = self.value.get('screen', None)
            stacktrace = self.value.get('stacktrace', None)

        raise WebDriverException(error, message, screen, stacktrace)

def raise_for_status ( self ) : if not self . status : return error = find_exception_by_code ( self . status ) message = None screen = None stacktrace = None if isinstance ( self . value , str ) : message = self . value elif isinstance ( self . value , dict ) : message = self . value . get ( 'message' , None ) screen = self . value . get ( 'screen' , None ) stacktrace = self . value . get ( 'stacktrace' , None ) raise WebDriverException ( error , message , screen , stacktrace )

Raise WebDriverException if returned status is not zero .


def fluent(func):
    """Fluent interface decorator to return self if method return None."""
    @wraps(func)
    def fluent_interface(instance, *args, **kwargs):
        ret = func(instance, *args, **kwargs)
        if ret is not None:
            return ret
        return instance
    return fluent_interface

def fluent ( func ) : @ wraps ( func ) def fluent_interface ( instance , * args , * * kwargs ) : ret = func ( instance , * args , * * kwargs ) if ret is not None : return ret return instance return fluent_interface

Fluent interface decorator to return self if method return None .


def check_unused_args(self, used_args, args, kwargs):
        """Implement the check_unused_args in superclass."""
        for k, v in kwargs.items():
            if k in used_args:
                self._used_kwargs.update({k: v})
            else:
                self._unused_kwargs.update({k: v})

def check_unused_args ( self , used_args , args , kwargs ) : for k , v in kwargs . items ( ) : if k in used_args : self . _used_kwargs . update ( { k : v } ) else : self . _unused_kwargs . update ( { k : v } )

Implement the check_unused_args in superclass .


def vformat(self, format_string, args, kwargs):
        """Clear used and unused dicts before each formatting."""
        self._used_kwargs = {}
        self._unused_kwargs = {}
        return super(MemorizeFormatter, self).vformat(format_string, args, kwargs)

def vformat ( self , format_string , args , kwargs ) : self . _used_kwargs = { } self . _unused_kwargs = { } return super ( MemorizeFormatter , self ) . vformat ( format_string , args , kwargs )

Clear used and unused dicts before each formatting .


def format_map(self, format_string, mapping):
        """format a string by a map

        Args:
            format_string(str): A format string
            mapping(dict): A map to format the string

        Returns:
            A formatted string.

        Raises:
            KeyError: if key is not provided by the given map.
        """
        return self.vformat(format_string, args=None, kwargs=mapping)

def format_map ( self , format_string , mapping ) : return self . vformat ( format_string , args = None , kwargs = mapping )


def find_exception_by_code(code):
    """Find name of exception by WebDriver defined error code.

    Args:
        code(str): Error code defined in protocol.

    Returns:
        The error name defined in protocol.
    """
    errorName = None
    for error in WebDriverError:
        if error.value.code == code:
            errorName = error
            break
    return errorName

def find_exception_by_code ( code ) : errorName = None for error in WebDriverError : if error . value . code == code : errorName = error break return errorName

Find name of exception by WebDriver defined error code .


def execute(self, command, data={}):
        """Format the endpoint url by data and then request the remote server.

        Args:
            command(Command): WebDriver command to be executed.
            data(dict): Data fulfill the uri template and json body.

        Returns:
            A dict represent the json body from server response.

        Raises:
            KeyError: Data cannot fulfill the variable which command needed.
            ConnectionError: Meet network problem (e.g. DNS failure,
                refused connection, etc).
            Timeout: A request times out.
            HTTPError: HTTP request returned an unsuccessful status code.
        """
        method, uri = command
        try:
            path = self._formatter.format_map(uri, data)
            body = self._formatter.get_unused_kwargs()
            url = "{0}{1}".format(self._url, path)
            return self._request(method, url, body)
        except KeyError as err:
            LOGGER.debug(
                'Endpoint {0} is missing argument {1}'.format(uri, err))
            raise

def
execute
(
self
,
command
,
data
=
{
}
)
:
method
,
uri
=
command
try
:
path
=
self
.
_formatter
.
format_map
(
uri
,
data
)
body
=
self
.
_formatter
.
get_unused_kwargs
(
)
url
=
"{0}{1}"
.
format
(
self
.
_url
,
path
)
return
self
.
_request
(
method
,
url
,
body
)
except
KeyError
as
err
:
LOGGER
.
debug
(
'Endpoint {0} is missing argument {1}'
.
format
(
uri
,
err
)
)
raise

Format the endpoint url by data and then request the remote server .


def _request(self, method, url, body):
        """Internal method to send request to the remote server.

        Args:
            method(str): HTTP Method(GET/POST/PUT/DELET/HEAD).
            url(str): The request url.
            body(dict): The JSON object to be sent.

        Returns:
            A dict represent the json body from server response.

        Raises:
            ConnectionError: Meet network problem (e.g. DNS failure,
                refused connection, etc).
            Timeout: A request times out.
            HTTPError: HTTP request returned an unsuccessful status code.
        """
        if method != 'POST' and method != 'PUT':
            body = None

        s = Session()

        LOGGER.debug(
            'Method: {0}, Url: {1}, Body: {2}.'.format(method, url, body))

        req = Request(method, url, json=body)
        prepped = s.prepare_request(req)

        res = s.send(prepped, timeout=self._timeout or None)
        res.raise_for_status()
        # TODO try catch
        return res.json()

def
_request
(
self
,
method
,
url
,
body
)
:
if
method
!=
'POST'
and
method
!=
'PUT'
:
body
=
s
=
Session
(
)
LOGGER
.
debug
(
'Method: {0}, Url: {1}, Body: {2}.'
.
format
(
method
,
url
,
body
)
)
req
=
Request
(
method
,
url
,
json
=
body
)
prepped
=
s
.
prepare_request
(
req
)
res
=
s
.
send
(
prepped
,
timeout
=
self
.
_timeout
or
)
res
.
raise_for_status
(
)
# TODO try catch
return
res
.
json
(
)

Internal method to send request to the remote server .


def _execute(self, command, data=None, unpack=True):
        """Private method to execute command with data.

        Args:
            command(Command): The defined command.
            data(dict): The uri variable and body.

        Returns:
            The unwrapped value field in the json response.
        """
        if not data:
            data = {}
        data.setdefault('element_id', self.element_id)
        return self._driver._execute(command, data, unpack)

def _execute ( self , command , data = None , unpack = True ) : if not data : data = { } data . setdefault ( 'element_id' , self . element_id ) return self . _driver . _execute ( command , data , unpack )

Private method to execute command with data .


def element(self, using, value):
        """find an element in the current element.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            WebElement Object.

        Raises:
            WebDriverException.
        """
        return self._execute(Command.FIND_CHILD_ELEMENT, {
            'using': using,
            'value': value
        })

def element ( self , using , value ) : return self . _execute ( Command . FIND_CHILD_ELEMENT , { 'using' : using , 'value' : value } )

find an element in the current element .


def element_or_none(self, using, value):
        """Check if an element in the current element.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            Return Element if the element does exists and return None otherwise.

        Raises:
            WebDriverException.
        """
        try:
            return self._execute(Command.FIND_CHILD_ELEMENT, {
                'using': using,
                'value': value
            })
        except:
            return None

def element_or_none ( self , using , value ) : try : return self . _execute ( Command . FIND_CHILD_ELEMENT , { 'using' : using , 'value' : value } ) except : return None

Check if an element in the current element .


def elements(self, using, value):
        """find elements in the current element.

        Support:
            Android iOS Web(WebView)

        Args:
            using(str): The element location strategy.
            value(str): The value of the location strategy.

        Returns:
            Return a List<Element | None>, if no element matched, the list is empty.

        Raises:
            WebDriverException.
        """
        return self._execute(Command.FIND_CHILD_ELEMENTS, {
            'using': using,
            'value': value
        })

def elements ( self , using , value ) : return self . _execute ( Command . FIND_CHILD_ELEMENTS , { 'using' : using , 'value' : value } )


def is_displayed(target):
    """Assert whether the target is displayed

    Args:
        target(WebElement): WebElement Object.

    Returns:
        Return True if the element is displayed or return False otherwise.
    """
    is_displayed = getattr(target, 'is_displayed', None)
    if not is_displayed or not callable(is_displayed):
        raise TypeError('Target has no attribute \'is_displayed\' or not callable')
    if not is_displayed():
        raise WebDriverException('element not visible')


def PlugIn(self):
        """Take next available controller id and plug in to Virtual USB Bus"""
        ids = self.available_ids()
        if len(ids) == 0:
            raise MaxInputsReachedError('Max Inputs Reached')

        self.id = ids[0]

        _xinput.PlugIn(self.id)
        while self.id in self.available_ids():
            pass

def
PlugIn
(
self
)
:
ids
=
self
.
available_ids
(
)
if
len
(
ids
)
==
0
:
raise
MaxInputsReachedError
(
'Max Inputs Reached'
)
self
.
id
=
ids
[
0
]
_xinput
.
PlugIn
(
self
.
id
)
while
self
.
id
in
self
.
available_ids
(
)
:
pass


def UnPlug(self, force=False):
        """Unplug controller from Virtual USB Bus and free up ID"""
        if force:
            _xinput.UnPlugForce(c_uint(self.id))
        else:
            _xinput.UnPlug(c_uint(self.id))
        while self.id not in self.available_ids():
            if self.id == 0:
                break

def UnPlug ( self , force = False ) : if force : _xinput . UnPlugForce ( c_uint ( self . id ) ) else : _xinput . UnPlug ( c_uint ( self . id ) ) while self . id not in self . available_ids ( ) : if self . id == 0 : break


def set_value(self, control, value=None):
        """Set a value on the controller
    If percent is True all controls will accept a value between -1.0 and 1.0

    If not then:
        Triggers are 0 to 255
        Axis are -32768 to 32767

    Control List:
        AxisLx          , Left Stick X-Axis
        AxisLy          , Left Stick Y-Axis
        AxisRx          , Right Stick X-Axis
        AxisRy          , Right Stick Y-Axis
        BtnBack         , Menu/Back Button
        BtnStart        , Start Button
        BtnA            , A Button
        BtnB            , B Button
        BtnX            , X Button
        BtnY            , Y Button
        BtnThumbL       , Left Thumbstick Click
        BtnThumbR       , Right Thumbstick Click
        BtnShoulderL    , Left Shoulder Button
        BtnShoulderR    , Right Shoulder Button
        Dpad            , Set Dpad Value (0 = Off, Use DPAD_### Constants)
        TriggerL        , Left Trigger
        TriggerR        , Right Trigger

    """
        func = getattr(_xinput, 'Set' + control)

        if 'Axis' in control:
            target_type = c_short

            if self.percent:
                target_value = int(32767 * value)
            else:
                target_value = value
        elif 'Btn' in control:
            target_type = c_bool
            target_value = bool(value)
        elif 'Trigger' in control:
            target_type = c_byte

            if self.percent:
                target_value = int(255 * value)
            else:
                target_value = value
        elif 'Dpad' in control:
            target_type = c_int
            target_value = int(value)

        func(c_uint(self.id), target_type(target_value))

def set_value ( self , control , value = None ) : func = getattr ( _xinput , 'Set' + control ) if 'Axis' in control : target_type = c_short if self . percent : target_value = int ( 32767 * value ) else : target_value = value elif 'Btn' in control : target_type = c_bool target_value = bool ( value ) elif 'Trigger' in control : target_type = c_byte if self . percent : target_value = int ( 255 * value ) else : target_value = value elif 'Dpad' in control : target_type = c_int target_value = int ( value ) func ( c_uint ( self . id ) , target_type ( target_value ) )

Set a value on the controller If percent is True all controls will accept a value between - 1 . 0 and 1 . 0


def main():
    """Test the functionality of the rController object"""
    import time

    print('Testing controller in position 1:')
    print('Running 3 x 3 seconds tests')

    # Initialise Controller
    con = rController(1)

    # Loop printing controller state and buttons held
    for i in range(3):
        print('Waiting...')
        time.sleep(2.5)
        print('State: ', con.gamepad)
        print('Buttons: ', con.buttons)
        time.sleep(0.5)

    print('Done!')


def gamepad(self):
        """Returns the current gamepad state. Buttons pressed is shown as a raw integer value.
        Use rController.buttons for a list of buttons pressed.
        """
        state = _xinput_state()
        _xinput.XInputGetState(self.ControllerID - 1, pointer(state))
        self.dwPacketNumber = state.dwPacketNumber

        return state.XINPUT_GAMEPAD

def gamepad ( self ) : state = _xinput_state ( ) _xinput . XInputGetState ( self . ControllerID - 1 , pointer ( state ) ) self . dwPacketNumber = state . dwPacketNumber return state . XINPUT_GAMEPAD

Returns the current gamepad state . Buttons pressed is shown as a raw integer value . Use rController . buttons for a list of buttons pressed .


def buttons(self):
        """Returns a list of buttons currently pressed"""
        return [name for name, value in rController._buttons.items()
                if self.gamepad.wButtons & value == value]

def buttons ( self ) : return [ name for name , value in rController . _buttons . items ( ) if self . gamepad . wButtons & value == value ]


def maybe_decode_header(header):
    """
    Decodes an encoded 7-bit ASCII header value into it's actual value.
    """
    value, encoding = decode_header(header)[0]
    if encoding:
        return value.decode(encoding)
    else:
        return value

def maybe_decode_header ( header ) : value , encoding = decode_header ( header ) [ 0 ] if encoding : return value . decode ( encoding ) else : return value

Decodes an encoded 7 - bit ASCII header value into it s actual value .


def autodiscover():
    """
    Imports all available previews classes.
    """
    from django.conf import settings
    for application in settings.INSTALLED_APPS:
        module = import_module(application)

        if module_has_submodule(module, 'emails'):
            emails = import_module('%s.emails' % application)
            try:
                import_module('%s.emails.previews' % application)
            except ImportError:
                # Only raise the exception if this module contains previews and
                # there was a problem importing them. (An emails module that
                # does not contain previews is not an error.)
                if module_has_submodule(emails, 'previews'):
                    raise

Imports all available previews classes .


def register(self, cls):
        """
        Adds a preview to the index.
        """
        preview = cls(site=self)
        logger.debug('Registering %r with %r', preview, self)
        index = self.__previews.setdefault(preview.module, {})
        index[cls.__name__] = preview

def
register
(
self
,
cls
)
:
preview
=
cls
(
site
=
self
)
logger
.
debug
(
'Registering %r with %r'
,
preview
,
self
)
index
=
self
.
__previews
.
setdefault
(
preview
.
module
,
{
}
)
index
[
cls
.
__name__
]
=
preview


def detail_view(self, request, module, preview):
        """
        Looks up a preview in the index, returning a detail view response.
        """
        try:
            preview = self.__previews[module][preview]
        except KeyError:
            raise Http404  # The provided module/preview does not exist in the index.
        return preview.detail_view(request)

Looks up a preview in the index returning a detail view response .


def url(self):
        """
        The URL to access this preview.
        """
        return reverse('%s:detail' % URL_NAMESPACE, kwargs={
            'module': self.module,
            'preview': type(self).__name__,
        })

def url ( self ) : return reverse ( '%s:detail' % URL_NAMESPACE , kwargs = { 'module' : self . module , 'preview' : type ( self ) . __name__ , } )


def detail_view(self, request):
        """
        Renders the message view to a response.
        """
        context = {
            'preview': self,
        }

        kwargs = {}
        if self.form_class:
            if request.GET:
                form = self.form_class(data=request.GET)
            else:
                form = self.form_class()

            context['form'] = form
            if not form.is_bound or not form.is_valid():
                return render(request, 'mailviews/previews/detail.html', context)

            kwargs.update(form.get_message_view_kwargs())

        message_view = self.get_message_view(request, **kwargs)

        message = message_view.render_to_message()
        raw = message.message()
        headers = OrderedDict((header, maybe_decode_header(raw[header])) for header in self.headers)

        context.update({
            'message': message,
            'subject': message.subject,
            'body': message.body,
            'headers': headers,
            'raw': raw.as_string(),
        })

        alternatives = getattr(message, 'alternatives', [])
        try:
            html = next(alternative[0] for alternative in alternatives
                if alternative[1] == 'text/html')
            context.update({
                'html': html,
                'escaped_html': b64encode(html.encode('utf-8')),
            })
        except StopIteration:
            pass

        return render(request, self.template_name, context)

def detail_view ( self , request ) : context = { 'preview' : self , } kwargs = { } if self . form_class : if request . GET : form = self . form_class ( data = request . GET ) else : form = self . form_class ( ) context [ 'form' ] = form if not form . is_bound or not form . is_valid ( ) : return render ( request , 'mailviews/previews/detail.html' , context ) kwargs . update ( form . get_message_view_kwargs ( ) ) message_view = self . get_message_view ( request , * * kwargs ) message = message_view . render_to_message ( ) raw = message . message ( ) headers = OrderedDict ( ( header , maybe_decode_header ( raw [ header ] ) ) for header in self . headers ) context . update ( { 'message' : message , 'subject' : message . subject , 'body' : message . body , 'headers' : headers , 'raw' : raw . as_string ( ) , } ) alternatives = getattr ( message , 'alternatives' , [ ] ) try : html = next ( alternative [ 0 ] for alternative in alternatives if alternative [ 1 ] == 'text/html' ) context . update ( { 'html' : html , 'escaped_html' : b64encode ( html . encode ( 'utf-8' ) ) , } ) except StopIteration : pass return render ( request , self . template_name , context )

Renders the message view to a response .


def split_docstring(value):
    """
    Splits the docstring of the given value into it's summary and body.

    :returns: a 2-tuple of the format ``(summary, body)``
    """
    docstring = textwrap.dedent(getattr(value, '__doc__', ''))
    if not docstring:
        return None

    pieces = docstring.strip().split('\n\n', 1)
    try:
        body = pieces[1]
    except IndexError:
        body = None

    return Docstring(pieces[0], body)

def split_docstring ( value ) : docstring = textwrap . dedent ( getattr ( value , '__doc__' , '' ) ) if not docstring : return None pieces = docstring . strip ( ) . split ( '\n\n' , 1 ) try : body = pieces [ 1 ] except IndexError : body = None return Docstring ( pieces [ 0 ] , body )

Splits the docstring of the given value into it s summary and body .


def render_to_message(self, extra_context=None, **kwargs):
        """
        Renders and returns an unsent message with the provided context.

        Any extra keyword arguments passed will be passed through as keyword
        arguments to the message constructor.

        :param extra_context: Any additional context to use when rendering the
            templated content.
        :type extra_context: :class:`dict`
        :returns: A message instance.
        :rtype: :attr:`.message_class`
        """
        if extra_context is None:
            extra_context = {}

        # Ensure our custom headers are added to the underlying message class.
        kwargs.setdefault('headers', {}).update(self.headers)

        context = self.get_context_data(**extra_context)
        return self.message_class(
            subject=self.render_subject(context),
            body=self.render_body(context),
            **kwargs)

Renders and returns an unsent message with the provided context .


def send(self, extra_context=None, **kwargs):
        """
        Renders and sends an email message.

        All keyword arguments other than ``extra_context`` are passed through
        as keyword arguments when constructing a new :attr:`message_class`
        instance for this message.

        This method exists primarily for convenience, and the proper
        rendering of your message should not depend on the behavior of this
        method. To alter how a message is created, override
        :meth:``render_to_message`` instead, since that should always be
        called, even if a message is not sent.

        :param extra_context: Any additional context data that will be used
            when rendering this message.
        :type extra_context: :class:`dict`
        """
        message = self.render_to_message(extra_context=extra_context, **kwargs)
        return message.send()

def send ( self , extra_context = None , * * kwargs ) : message = self . render_to_message ( extra_context = extra_context , * * kwargs ) return message . send ( )


def render_subject(self, context):
        """
        Renders the message subject for the given context.

        The context data is automatically unescaped to avoid rendering HTML
        entities in ``text/plain`` content.

        :param context: The context to use when rendering the subject template.
        :type context: :class:`~django.template.Context`
        :returns: A rendered subject.
        :rtype: :class:`str`
        """
        rendered = self.subject_template.render(unescape(context))
        return rendered.strip()

def render_subject ( self , context ) : rendered = self . subject_template . render ( unescape ( context ) ) return rendered . strip ( )

Renders the message subject for the given context .


def render_to_message(self, extra_context=None, *args, **kwargs):
        """
        Renders and returns an unsent message with the given context.

        Any extra keyword arguments passed will be passed through as keyword
        arguments to the message constructor.

        :param extra_context: Any additional context to use when rendering
            templated content.
        :type extra_context: :class:`dict`
        :returns: A message instance.
        :rtype: :attr:`.message_class`
        """
        message = super(TemplatedHTMLEmailMessageView, self)\
            .render_to_message(extra_context, *args, **kwargs)

        if extra_context is None:
            extra_context = {}

        context = self.get_context_data(**extra_context)
        content = self.render_html_body(context)
        message.attach_alternative(content, mimetype='text/html')
        return message

def render_to_message ( self , extra_context = None , * args , * * kwargs ) : message = super ( TemplatedHTMLEmailMessageView , self ) . render_to_message ( extra_context , * args , * * kwargs ) if extra_context is None : extra_context = { } context = self . get_context_data ( * * extra_context ) content = self . render_html_body ( context ) message . attach_alternative ( content , mimetype = 'text/html' ) return message

Renders and returns an unsent message with the given context .


def numeric(_, n):
    """
    NBASE = 1000
    ndigits = total number of base-NBASE digits
    weight = base-NBASE weight of first digit
    sign = 0x0000 if positive, 0x4000 if negative, 0xC000 if nan
    dscale = decimal digits after decimal place
    """
    try:
        nt = n.as_tuple()
    except AttributeError:
        raise TypeError('numeric field requires Decimal value (got %r)' % n)
    digits = []
    if isinstance(nt.exponent, str):
        # NaN, Inf, -Inf
        ndigits = 0
        weight = 0
        sign = 0xC000
        dscale = 0
    else:
        decdigits = list(reversed(nt.digits + (nt.exponent % 4) * (0,)))
        weight = 0
        while decdigits:
            if any(decdigits[:4]):
                break
            weight += 1
            del decdigits[:4]
        while decdigits:
            digits.insert(0, ndig(decdigits[:4]))
            del decdigits[:4]
        ndigits = len(digits)
        weight += nt.exponent // 4 + ndigits - 1
        sign = nt.sign * 0x4000
        dscale = -min(0, nt.exponent)
    data = [ndigits, weight, sign, dscale] + digits
    return ('ihhHH%dH' % ndigits, [2 * len(data)] + data)

NBASE = 1000 ndigits = total number of base - NBASE digits weight = base - NBASE weight of first digit sign = 0x0000 if positive 0x4000 if negative 0xC000 if nan dscale = decimal digits after decimal place