class SquareAction(Action): """ This is an example of a simple action which takes a single input argument - a number to square - and returns the square of it. """ # The SOA library enables validation of both requests and responses using the "conformity" library. Simple schemas # can be specified inline like this; more complex ones should live in a separate schemas/ package (see other # examples). request_schema = fields.Dictionary({ # Request bodies are always dictionaries. Here we say we want a dict with exactly one input - a float called # "number" 'number': fields.Float(), }) response_schema = fields.Dictionary({ 'square': fields.Float(), }) def run(self, request): """ When an action is run, the request is validated, and then passed to you here in the run() method, where you can perform the business logic. """ # Request body is a dictionary, so it's easy to pull out fields. square = request.body['number'] ** 2 # Return the result return { 'square': square, }
def test_schema_correct(self): assert SettingsOneThree.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.List(fields.Float()), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsThreeTwoOne.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Integer(), 'baz': fields.List(fields.Float()), 'qux': fields.Float(), }
class SettingsThree(Settings): schema = { 'baz': fields.List(fields.Float()), 'qux': fields.Float(), } # type: SettingsSchema defaults = { 'qux': 1.234, } # type: SettingsData
class SettingsToTest(settings.Settings): schema: settings.SettingsSchema = { 'one': fields.Dictionary({ 'a': fields.ClassConfigurationSchema(base_class=ClassUsingAttrs27HintsToTest, description='Nifty schema.'), 'b': fields.PythonPath(value_schema=fields.UnicodeString(), description='Must be a path, yo.'), 'c': fields.TypeReference(base_classes=ClassHoldingSigsToTest, description='Refer to that thing!'), }), 'two': fields.SchemalessDictionary(key_type=fields.UnicodeString(), value_type=fields.Boolean()), 'three': fields.List(fields.Integer()), 'four': fields.Nullable(fields.Set(fields.ByteString())), 'five': fields.Any(fields.Integer(), fields.Float()), 'six': fields.ObjectInstance(valid_type=ClassUsingAttrs27HintsToTest, description='Y u no instance?'), 'seven': fields.Polymorph( 'thing', { 'thing1': fields.Dictionary({'z': fields.Boolean()}, allow_extra_keys=True), 'thing2': fields.Dictionary({'y': fields.Boolean()}, allow_extra_keys=True, optional_keys=('y', )), }, ), } defaults: settings.SettingsData = { 'one': { 'b': 'foo.bar:Class', }, 'three': [1, 5, 7], }
def test_schema_correct(self): assert SettingsOneTwoThreeWithOverrides.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.ByteString(), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsOneTwoThree.schema == { 'foo': fields.UnicodeString(), 'bar': fields.Boolean(), 'baz': fields.Dictionary( { 'inner_foo': fields.UnicodeString(), 'inner_bar': fields.Boolean(), 'inner_baz': fields.List(fields.Integer()), 'inner_qux': fields.Dictionary( { 'most_inner_foo': fields.Boolean(), 'most_inner_bar': fields.UnicodeString(), }, ), }, ), 'qux': fields.Float(), }
def test_schema_correct(self): assert SettingsFour.schema == { 'baz': fields.List(fields.Float()), 'qux': fields.Decimal(), 'new': fields.ByteString(), 'old': fields.UnicodeString(), }
class TypesEchoAction(Action): request_schema = fields.Dictionary( { 'an_int': fields.Integer(), 'a_float': fields.Float(), 'a_bool': fields.Boolean(), 'a_bytes': fields.ByteString(), 'a_string': fields.UnicodeString(), 'a_datetime': fields.DateTime(), 'a_date': fields.Date(), 'a_time': fields.Time(), 'a_list': fields.List(fields.Anything(), max_length=0), 'a_dict': fields.Nullable(fields.Dictionary({})), }, optional_keys=( 'an_int', 'a_float', 'a_bool', 'a_bytes', 'a_string', 'a_datetime', 'a_date', 'a_time', 'a_list', 'a_dict', ), ) response_schema = fields.Dictionary( {'r_{}'.format(k): v for k, v in six.iteritems(request_schema.contents)}, optional_keys=('r_{}'.format(k) for k in request_schema.optional_keys), ) def run(self, request): return {'r_{}'.format(k): v for k, v in six.iteritems(request.body)}
class WalkAction(Action): request_schema = fields.Dictionary({'value': fields.Any(fields.Integer(), fields.Float())}) response_schema = request_schema add = 1 def run(self, request): return {'value': request.body['value'] + self.add}
class CallServiceAction(Action): """ This is an example of a simple action which chains down to call another service; in this case, ourselves, which is unusual, but it's an easier example than creating another service. """ response_schema = fields.Dictionary({ 'square': fields.Float(), }) def run(self, request): """ When an action is run, the request is validated, and then passed to you here in the run() method, where you can perform the business logic. """ # The client, which lets us call other services, is always available on the request object if any client routing # settings are configured in the service settings. In this case, the service is calling itself, which can only # work if there are two or more server processes running. result = request.client.call_action('example', 'square', body={'number': 42}) return { 'square': result.body['square'], }
def test_schema_correct(self): assert SettingsThree.schema == { 'baz': fields.List(fields.Float()), 'qux': fields.Float(), }
MAX_GIG_E_MTU_BYTES = 9000 MAX_FAST_E_MTU_BYTES = 1518 MAX_IPV4_PAYLOAD_SIZE_BYTES = MAX_IPV4_PACKET_SIZE_BYTES - IP_HEADER_BYTES - UDP_HEADER_BYTES MAX_GIG_E_PAYLOAD_SIZE_BYTES = MAX_GIG_E_MTU_BYTES - IP_HEADER_BYTES - UDP_HEADER_BYTES MAX_FAST_E_PAYLOAD_SIZE_BYTES = MAX_FAST_E_MTU_BYTES - IP_HEADER_BYTES - UDP_HEADER_BYTES @fields.ClassConfigurationSchema.provider(fields.Dictionary( { 'host': fields.UnicodeString(description='The host name or IP address on which the Statsd server is listening'), 'port': fields.Integer(description='The port number on which the Statsd server is listening'), 'maximum_packet_size': fields.Integer( description='The maximum packet size to send (packets will be fragmented above this limit), defaults to ' '65000 bytes.', ), 'network_timeout': fields.Any(fields.Float(gt=0.0), fields.Integer(gt=0), description='The network timeout'), }, optional_keys=('maximum_packet_size', 'network_timeout'), )) class StatsdPublisher(MetricsPublisher): """ A publisher that emits UDP metrics packets to a Statsd consumer over a network connection. For Statsd metric type suffixes, see https://github.com/etsy/statsd/blob/master/docs/metric_types.md. """ METRIC_TYPE_COUNTER = b'c' METRIC_TYPE_GAUGE = b'g' METRIC_TYPE_HISTOGRAM = b'ms' METRIC_TYPE_TIMER = b'ms'
from pymetrics.instruments import ( Counter, Gauge, Histogram, Metric, Tag, Timer, TimerResolution, ) from pymetrics.publishers.statsd import StatsdPublisher __all__ = ('DogStatsdPublisher', ) _datadog_tags_value_type = fields.Nullable( fields.Any(fields.UnicodeString(), fields.ByteString(), fields.Integer(), fields.Float(), fields.Boolean()), ) @fields.ClassConfigurationSchema.provider( fields.Dictionary( { 'host': fields.UnicodeString( description= 'The host name or IP address on which the Dogstatsd server is listening', ), 'port': fields.Integer( description= 'The port number on which the Dogstatsd server is listening'), 'maximum_packet_size':