How to use the colander.Int function in colander

def test_get_sheets_with_field(self, request_, context, sheet_meta):
        class SchemaF(colander.MappingSchema):
            test = colander.SchemaNode(colander.Int())
        sheet_meta = sheet_meta._replace(schema_class=SchemaF)
        request_.registry.content.sheets_meta[ISheet] = sheet_meta
        inst = self.make_one(request_, context)

        response = inst.get()['sheets'][ISheet.__identifier__]

        assert len(response['fields']) == 1
        field_metadata = response['fields'][0]
        assert field_metadata['create_mandatory'] is False
        assert field_metadata['readable'] is True
        assert field_metadata['editable'] is True
        assert field_metadata['creatable'] is True
        assert field_metadata['name'] == 'test'
        assert 'valuetype' in field_metadata

def make_one(self, **kwargs):
        from . import SequenceSchema

        class AdhocracySequenceExample(SequenceSchema):
            child1 = colander.Schema(typ=colander.Int())
        return AdhocracySequenceExample(**kwargs).bind()

from adhocracy_core.interfaces import ISheet
from adhocracy_core.interfaces import IResource
from adhocracy_core.testing import register_sheet


class IResourceX(IResource):
    pass


class ISheetB(ISheet):
    pass


class CountSchema(colander.MappingSchema):

    count = colander.SchemaNode(colander.Int(),
                                default=0,
                                missing=colander.drop)


@fixture
def mock_authpolicy(registry):
    from pyramid.interfaces import IAuthenticationPolicy
    from adhocracy_core.authentication import TokenHeaderAuthenticationPolicy
    policy = Mock(spec=TokenHeaderAuthenticationPolicy)
    registry.registerUtility(policy, IAuthenticationPolicy)
    return policy


@fixture
def mock_password_sheet(registry_with_content, sheet_meta):
    from adhocracy_core.sheets.principal import IPasswordAuthentication

"a (lon, lat, depth) triple\n"
                         "a Nx2 array-like object of (lon, lat)\n"
                         "a Nx3 array-like object of (lon, lat, depth)\n"
                         )


class ProjectionSchema(ObjTypeSchema):
    bounding_box = TupleSchema(
        missing=drop, save=True, update=False,
        children=[TupleSchema(children=[SchemaNode(Float()),
                                        SchemaNode(Float())]),
                  TupleSchema(children=[SchemaNode(Float()),
                                        SchemaNode(Float())])
                  ])
    image_size = TupleSchema(save=True, update=True, missing=drop,
                             children=[SchemaNode(Int()), SchemaNode(Int())])


class NoProjection(GnomeId):
    """
    This is do-nothing projection class -- returns what it gets.

    It optionally rounds down to integer (pixel) coordinates

    used for testing, primarily, and as a definition of the interface
    """
    _schema = ProjectionSchema

    def set_scale(self, bounding_box, image_size=None):
        """
        Does nothing
        """

class WindageSchema(TupleSchema):
    min_windage = SchemaNode(Float(), validator=Range(0, 1.0),
                             default=0.01)
    max_windage = SchemaNode(Float(), validator=Range(0, 1.0),
                             default=0.04)


class InitWindagesSchema(base_schema.ObjTypeSchema):
    """
    windages initializer values
    """
    windage_range = WindageSchema(
        save=True, update=True,
    )
    windage_persist = SchemaNode(
        Int(), default=900, save=True, update=True,
    )


class InitWindages(InitBaseClass):
    _schema = InitWindagesSchema

    def __init__(self, windage_range=(0.01, 0.04), windage_persist=900, name='windages', *args, **kwargs):
        """
        Initializes the windages, windage_range, windage_persist data arrays.
        Initial values for windages use infinite persistence. These are updated
        by the WindMover for particles with non-zero persistence.

        Optional arguments:

        :param windage_range=(0.01, 0.04): the windage range of the elements
            default is (0.01, 0.04) from 1% to 4%.

**Required fields**

    :ivar epsilon: (*0.0 <= float64 <= 1.0*) epsilon value for epsilon-first bandit. This strategy pulls the optimal arm
      (best expected return) with if it is in exploitation phase (number sampled > epsilon * total_samples). Otherwise a random arm is pulled (exploration).
    :ivar total_samples: (*int >= 0*) total number of samples for epsilon-first bandit. total_samples is T from :doc:`bandit`.

    """

    epsilon = colander.SchemaNode(
            colander.Float(),
            validator=colander.Range(min=0.0, max=1.0),
            missing=DEFAULT_EPSILON,
            )

    total_samples = colander.SchemaNode(
            colander.Int(),
            validator=colander.Range(min=0),
            missing=DEFAULT_TOTAL_SAMPLES,
            )


class BanditEpsilonGreedyHyperparameterInfo(base_schemas.StrictMappingSchema):

    """The hyperparameter info needed for every  Bandit Epsilon request.

    **Required fields**

    :ivar epsilon: (*0.0 <= float64 <= 1.0*) epsilon value for epsilon-greedy bandit. This strategy pulls the optimal arm
      (best expected return) with probability 1-epsilon. With probability epsilon a random arm is pulled.

    """

default=MODES[0][0],
        missing=MODES[0][0],
        title="Operating mode",
        widget=deform.widget.RadioChoiceWidget(values=MODES)
    )

    drop_determiners = colander.SchemaNode(
        colander.Bool(),
        default=True,
        missing=False,
        label="Determiners are leading word particles (ex: the)",
        title='Drop determiners',
    )

    min_freq = colander.SchemaNode(
        colander.Int(),
        title="Minimum frequency count",
        description="""Ignore phrases with lower count then given number""",
        default=1,
    )


@pipeline_component(schema=NounChunks,
                    title="Find and process noun chunks")
def process(content, env, **settings):
    """ Noun Chunks processing
    """

    mode = settings.get('mode', 'tokenize')

    drop_deter = settings['drop_determiners']
    min_freq = int(settings['min_freq'])

""" Raised when a lock cannot be removed

    This may be because the owner suplied in the unlock request does not
    match the owner of the lock, or becaues the lock no longer exists.

    Instances of this class have a ``lock`` attribute which is a
    :class:`substanced.locking.Lock` object, representing the conflicting lock,
    or ``None`` if there was no lock to unlock.
    """

def now():
    return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)

class LockOwnerSchema(colander.SchemaNode):
    title = 'Owner'
    schema_type = colander.Int

    @property
    def widget(self):
        context = self.bindings['context']
        principals = find_service(context, 'principals')
        if principals is None:
            values = [] # fbo dump/load
        else:
            values = [(get_oid(group), name) for name, group in
                      principals['users'].items()]
        return deform.widget.Select2Widget(values=values)

    def validator(self, node, value):
        context = self.bindings['context']
        objectmap = find_objectmap(context)
        if not value in objectmap.objectid_to_path:

)
    start_position = WorldPoint(
        save=True, update=True
    )
    end_position = WorldPoint(
        missing=drop, save=True, update=True
    )
    _next_release_pos = WorldPointNumpy(
        missing=drop, save=True, read_only=True
    )
    end_release_time = SchemaNode(
        LocalDateTime(), missing=drop,
        validator=convertible_to_seconds,
        save=True, update=True
    )
    num_elements = SchemaNode(Int())
    num_per_timestep = SchemaNode(
        Int(), missing=drop, save=True, update=True
    )
    description = 'ContinuousRelease object schema'


class StartPositions(SequenceSchema):
    start_position = WorldPoint()


class SpatialReleaseSchema(BaseReleaseSchema):
    '''
    Contains properties required by UpdateWindMover and CreateWindMover
    TODO: also need a way to persist list of element_types
    '''
    description = 'SpatialRelease object schema'