def validate_data(request, attrs=None, validators=None):
logger.debug('attrs: %s', attrs)
logger.debug('body: %s', request.body)
data = json.loads(request.body)
data_to_validate = {
k: v
for k, v in data.items() if k in (attrs or {}).keys()
}
logger.debug('data_to_validate: %s', data_to_validate)
# missing field
if attrs and not data_to_validate:
raise Http400
# invalid field
if data_to_validate:
try:
attr.make_class("C", attrs)(**data_to_validate)
except (TypeError, ValueError):
raise Http400
# custom validation
for validate_func in (validators or []):
validate_func(request)
return data
def test_field_set_can_be_used_to_declare_multiple_fields_in_one_attribute():
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
BookRecord = attr.make_class("BookRecord", ["title"])
class Author(StaticDataObjectType):
__records__ = [AuthorRecord("PG Wodehouse")]
name = field(type=String)
class Book(StaticDataObjectType):
__records__ = [BookRecord("Leave it to Psmith")]
title = field(type=String)
class Root(RootType):
fields = field_set(
author=single(lambda: StaticDataObjectType.select(Author)),
book=single(lambda: StaticDataObjectType.select(Book)),
)
result = executor(Root)("{ author { name } book { title } }")
assert_that(
result,
is_successful_result(
data={
"author": {
"name": "PG Wodehouse"
},
"book": {
"title": "Leave it to Psmith"
},
}))
def main():
p = Person(name="kute", salary=1000, age=18)
print(p)
print(p.tall)
print(attr.asdict(p)) # 字典转换
print(attr.astuple(p)) # 元组
print(attr.fields(Person))
s = Square(5)
print(s, s.y)
personlist = PersonList(persons=[
Person("kute", 1000, 18),
Person("bai", 2000, 20),
Person("yalong", 3000, 22)
],
id="10086",
num=76)
result = attr.asdict(personlist, filter=filter_pro) # 过滤方式1
print(result)
# 过滤 id 和 num成员,以及 值类型为 str 的值
result = attr.asdict(personlist,
filter=attr.filters.exclude(
attr.fields(PersonList).id, str,
attr.fields(PersonList).num))
print(result)
# 创建一个类
C = attr.make_class("C", ["x", "y"])
B = attr.make_class("B", {"x": attr.ib(), "y": attr.ib()})
c = C(x=1, y=2)
b = B(2, 3)
print(c, b)
def validate_data(request, attrs=None, validators=None):
logger.debug('attrs: %s', attrs)
logger.debug('body: %s', request.body)
data = json.loads(request.body)
data_to_validate = {k: v
for k, v in data.items()
if k in (attrs or {}).keys()}
logger.debug('data_to_validate: %s', data_to_validate)
# missing field
if attrs and not data_to_validate:
raise Http400
# invalid field
if data_to_validate:
try:
attr.make_class("C", attrs)(**data_to_validate)
except (TypeError, ValueError):
raise Http400
# custom validation
for validate_func in (validators or []):
validate_func(request)
return data
def test_internal_fields_cannot_be_queried_directly():
AuthorRecord = attr.make_class("AuthorRecord", ["id", "name"])
BookRecord = attr.make_class("BookRecord", ["author_id", "title"])
class Author(StaticDataObjectType):
__records__ = [
AuthorRecord("PGW", "PG Wodehouse"),
AuthorRecord("JH", "Joseph Heller"),
]
id = field(type=String)
name = field(type=String)
class Book(StaticDataObjectType):
__records__ = [
BookRecord("PGW", "Leave it to Psmith"),
BookRecord("PGW", "The Code of the Woosters"),
]
author_id = field(type=String, internal=True)
author = single(lambda: StaticDataObjectType.select(
Author,
join={Book.author_id: Author.id},
))
title = field(type=String)
class Root(RootType):
books = many(lambda: StaticDataObjectType.select(Book))
execute = executor(Root)
assert_that(
execute("{ books { title authorId } }"),
is_invalid_result(errors=contains_inanyorder(
has_string(starts_with('Cannot query field "authorId"')), )),
)
# Check that internal fields can still be used for joining
assert_that(
execute("{ books { title author { name } } }"),
is_successful_result(
data={
"books": [
{
"title": "Leave it to Psmith",
"author": {
"name": "PG Wodehouse"
}
},
{
"title": "The Code of the Woosters",
"author": {
"name": "PG Wodehouse"
}
},
],
}),
)
def test_create_dockerfile(self):
cls = attr.make_class(
'MockRecipes',
['install_nodejs', 'install_rust', 'yum_install', 'pip3_install'])
subrecipes = cls(None, None, None, None)
cls = attr.make_class('Mock', ['from_', 'recipes', 'workdir'])
obj = cls('baseImage', subrecipes, None)
lines = phase3.create_dockerfile(obj)
self.assertEqual(lines, 'FROM baseImage')
obj.workdir = '/test'
lines = phase3.create_dockerfile(obj)
self.assertEqual(lines, 'FROM baseImage\nWORKDIR /test')
def test_create_dockerfile_mock(self, pip3, nodejs, rust, yum):
pip3.return_value = 'pip3'
nodejs.return_value = ['nodejs']
rust.return_value = ['rust']
yum.return_value = 'yum'
cls = attr.make_class(
'MockRecipes',
['install_nodejs', 'install_rust', 'yum_install', 'pip3_install'])
subrecipes = cls('a', 'b', 'c', 'd')
cls = attr.make_class('Mock', ['from_', 'recipes', 'workdir'])
obj = cls('baseImage', subrecipes, None)
text = phase3.create_dockerfile(obj)
self.assertEqual(text, 'FROM baseImage\nyum\nrust\nnodejs\npip3')
def make_klass(spec):
"""
Create a data class given a spec.
Parameters
----------
spec :
TODO
"""
if spec is None:
return None
fields = spec.fields
if fields:
newfields = dict()
for item in fields:
if len(item) == 2:
if isinstance(item[1], attr._make._CountingAttr):
newfields[item[0]] = item[1]
else:
newfields[item[0]] = attr.ib(type=item[1])
else:
if isinstance(item[2], attr._make._CountingAttr):
raise ValueError("Three part should not have attr")
# newfields[item[0]] = item[2]
else:
newfields[item[0]] = attr.ib(item[2], type=item[1])
fields = newfields
return attr.make_class(spec.name, fields, bases=spec.bases, kw_only=True)
def _get_mock_data():
tmpdir = tmp_path_factory.mktemp(tools.get_output_name())
create_data_dir(tmpdir)
tmpdirs.append(tmpdir)
outdir = get_outdir(tmpdir)
data = tools.get_command_info(outdir)
cmd_exe_vals = ["user", "host", "cmd", "workdir"]
for k, v in data.items():
if "/" in v:
data[k] = Path(v)
data["create_sample_output"] = False
data["save_sample_output"] = False
for k in cmd_exe_vals:
data.pop(k, None)
DataClass = attr.make_class(data["test_name"] + "_data",
[k for k in data.keys()],
slots=True)
data = DataClass(*[v for v in data.values()])
return tmpdir, data
def test_structure_prefers_attrib_converters(converter_type):
attrib_converter = Mock()
attrib_converter.side_effect = lambda val: str(val)
converter = converter_type(prefer_attrib_converters=True)
cl = make_class(
"HasConverter",
{
# non-built-in type with custom converter
"ip":
attrib(type=Union[IPv4Address, IPv6Address], converter=ip_address),
# attribute without type
"x":
attrib(converter=attrib_converter),
# built-in types converters
"y":
attrib(type=int, converter=attrib_converter),
# attribute with type and default value
"z":
attrib(type=int, converter=attrib_converter, default=5),
},
)
inst = converter.structure(dict(ip="10.0.0.0", x=1, y=3), cl)
assert inst.ip == IPv4Address("10.0.0.0")
attrib_converter.assert_any_call(1)
assert inst.x == "1"
attrib_converter.assert_any_call(3)
assert inst.y == "3"
attrib_converter.assert_any_call(5)
assert inst.z == "5"
def test_structure_fallback_to_attrib_converters(converter_type):
attrib_converter = Mock()
attrib_converter.side_effect = lambda val: str(val)
def called_after_default_converter(val):
if not isinstance(val, int):
raise ValueError(
"The 'int' conversion should have happened first by the built-in hooks"
)
return 42
converter = converter_type()
cl = make_class(
"HasConverter",
{
# non-built-in type with custom converter
"ip":
attrib(type=Union[IPv4Address, IPv6Address], converter=ip_address),
# attribute without type
"x":
attrib(converter=attrib_converter),
# built-in types converters
"z":
attrib(type=int, converter=called_after_default_converter),
},
)
inst = converter.structure(dict(ip="10.0.0.0", x=1, z="3"), cl)
assert inst.ip == IPv4Address("10.0.0.0")
assert inst.x == "1"
attrib_converter.assert_any_call(1)
assert inst.z == 42
def test_run(self):
cls = attr.make_class('MockSet', ['a'])
recipe = cls(types.Value('b'))
steps = [types.Step('set', recipe, None)]
ctx = phase3.Context()
phase3.run(steps, ctx)
self.assertEqual(ctx.variables, {'a': 'b'})
def _get_plugin_reqs(plugin, injectables=None):
if injectables is None: # allow overriding for testability
injectables = get_injectables()
injectables.update(**plugin.overrides or {})
built = typesnap.lazy_snap(injectables, plugin.requires or (),
plugin.maybe_requires or ())
return attr.make_class('Requirements', sorted(built))(**built)
def _process_class(cls, kw_only: bool, make_init: bool, dynamic: bool):
"""Process a given class
Args:
cls: basic class definition
kw_only: set kwarg only
make_init: make an init function
dynamic: allows inherited classes to not be @spock decorated
Returns:
cls with attrs dunder methods added
"""
# Handles the MRO and gets old annotations
bases, attrs_dict, merged_annotations = _base_attr(cls, kw_only, make_init,
dynamic)
# Dynamically make an attr class
obj = attr.make_class(
name=cls.__name__,
bases=bases,
attrs=attrs_dict,
kw_only=kw_only,
frozen=True,
auto_attribs=True,
init=make_init,
)
# For each class we dynamically create we need to register it within the system modules for pickle to work
setattr(sys.modules["spock"].addons.tune.config, obj.__name__, obj)
# Swap the __doc__ string from cls to obj
obj.__doc__ = cls.__doc__
# Set the __init__ function
# Handle __annotations__ from the MRO
obj.__annotations__ = merged_annotations
return obj
def load_object(self, schema, val, path):
if isinstance(val, types.Step):
return self.load_step(schema, val, path)
else:
if not isinstance(val, collections.abc.Mapping):
raise TypeMismatch(path)
temp_obj = {}
if schema.wildcard_key():
for key in val:
subpath = path + [key]
temp_obj[key] = self.load_one(schema.fields[Key('*')],
val[key], subpath)
else:
for key in val:
if Key(key) not in schema.fields:
raise InvalidKey(path, key)
subpath = path + [key]
temp_obj[key] = self.load_one(schema.fields[Key(key)],
val[key], subpath)
for key in schema.fields:
if key.name not in temp_obj and key.name != '*':
temp_obj[key.name] = types.Value(None)
if key.is_required:
if key.name not in val:
raise MissingKey(path)
temp_obj = make_keys_safe(temp_obj)
cls = attr.make_class('SchemaClass', list(temp_obj.keys()))
return cls(**temp_obj)
def _create_hyp_class(attrs_and_strategy, frozen=None):
"""
A helper function for Hypothesis to generate attrs classes.
The result is a tuple: an attrs class, and a tuple of values to
instantiate it.
"""
def key(t):
return t[0].default is not NOTHING
attrs_and_strat = sorted(attrs_and_strategy, key=key)
attrs = [a[0] for a in attrs_and_strat]
for i, a in enumerate(attrs):
a.counter = i
vals = tuple((a[1]) for a in attrs_and_strat)
return st.tuples(
st.builds(
lambda f: make_class(
"HypClass", OrderedDict(zip(gen_attr_names(), attrs)), frozen=f
),
st.booleans() if frozen is None else st.just(frozen),
),
st.tuples(*vals),
)
def test_arg_refiner_can_take_context():
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
class Author(StaticDataObjectType):
__records__ = [
AuthorRecord("PG Wodehouse"),
AuthorRecord("Joseph Heller"),
]
name = field(type=String)
class Root(RootType):
author = single(lambda: StaticDataObjectType.select(Author))
@author.arg("nameStartsWith", Boolean)
def author_arg_starts_with(records, _, context):
return list(
filter(
lambda record: record.name.startswith(context),
records,
))
result = executor(Root)(
"""{ author(nameStartsWith: true) { name } }""",
context="P",
)
assert_that(
result,
is_successful_result(data={
"author": {
"name": "PG Wodehouse"
},
}))
def entity(cls):
for k, v in cls.__dict__.items():
if hasattr(v, 'init') and isinstance(v.init, bool):
v.init = False
result = attr.make_class(cls.__name__, (),
bases=(_Signature, attr.s(cls), _Entity))
return functools.wraps(cls, updated=())(result)
def data(request, output_dir):
"""A function-scoped test fixture used for AFNI's testing. The fixture
sets up output directories as required and provides the named tuple "data"
to the calling function. The data object contains some fields convenient
for writing tests like the output directory. Finally the data fixture
handles test input data.files listed in a data_paths dictionary (if
defined within the test module) the fixture will download them to a local
datalad repository as required. Paths should be listed relative to the
repository base-directory.
Args: request (pytest.fixture): A function level pytest request object
providing information about the calling test function.
Returns:
collections.NameTuple: A data object for conveniently handling the specification
"""
test_name = get_current_test_name()
tests_data_dir = get_tests_data_dir()
# Set module specific values:
try:
data_paths = request.module.data_paths
except AttributeError:
data_paths = {}
module_outdir = output_dir / Path(request.module.__file__).stem.replace(
"test_", "")
test_logdir = module_outdir / get_current_test_name() / "captured_output"
if not test_logdir.exists():
os.makedirs(test_logdir, exist_ok=True)
# This will be created as required later
sampdir = tools.convert_to_sample_dir_path(test_logdir.parent)
# start creating output dict, downloading test data as required
out_dict = {
k: misc.process_path_obj(v, tests_data_dir)
for k, v in data_paths.items()
}
# Get the comparison directory and check if it needs to be downloaded
comparison_dir = get_test_comparison_dir_path(module_outdir)
# Define output for calling module and get data as required:
out_dict.update({
"module_outdir": module_outdir,
"outdir": module_outdir / get_current_test_name(),
"sampdir": sampdir,
"logdir": test_logdir,
"comparison_dir": comparison_dir,
"base_comparison_dir": get_base_comparison_dir_path(),
"base_outdir": output_dir,
"tests_data_dir": tests_data_dir,
"test_name": test_name,
})
DataClass = attr.make_class(test_name + "_data",
[k for k in out_dict.keys()],
slots=True)
return DataClass(*[v for v in out_dict.values()])
def concepticon_concepts(concept_lists):
attrib = {}
for cl in concept_lists:
for col in cl.metadata.tableSchema.columns:
if col.name not in ['ID', 'CONCEPTICON_ID', 'CONCEPTICON_GLOSS']:
attrib[col.name] = attr.ib(default=None)
return attr.make_class("ConcepticonConcept", attrib, bases=(Concept,))
def test_can_define_input_object_types():
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
class AuthorSelection(InputObjectType):
name_starts_with = field(type=String)
class Author(StaticDataObjectType):
__records__ = [
AuthorRecord("PG Wodehouse"),
AuthorRecord("Joseph Heller"),
]
name = field(type=String)
class Root(RootType):
author = single(lambda: StaticDataObjectType.select(Author))
@author.arg("selection", AuthorSelection)
def author_arg_selection(records, selection):
return list(
filter(
lambda record: record.name.startswith(selection.
name_starts_with),
records,
))
result = executor(Root)(
"""{ author(selection: {nameStartsWith: "P"}) { name } }""")
assert_that(
result,
is_successful_result(data={
"author": {
"name": "PG Wodehouse"
},
}))
def test_structure_simple_from_dict_default(converter, cl_and_vals):
"""Test structuring non-nested attrs classes with default value."""
a, _ = cl_and_vals
cl = make_class("HypClass", {"a": a})
obj = cl()
loaded = converter.structure({}, cl)
assert obj == loaded
def __attrs_post_init__(self):
""" Build the constructor that can create feature structures of this type """
name = _string_to_valid_classname(self.name)
fields = {feature.name: attr.ib(default=None) for feature in self.all_features}
fields["type"] = attr.ib(default=self.name)
self._constructor = attr.make_class(name, fields, bases=(FeatureStructure,), slots=True, cmp=False)
def test_arg_method_can_be_used_as_decorator_to_refine_query():
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
class Author(StaticDataObjectType):
__records__ = [
AuthorRecord("PG Wodehouse"),
AuthorRecord("Joseph Heller"),
]
name = field(type=String)
class Root(RootType):
author = single(lambda: StaticDataObjectType.select(Author))
@author.arg("nameStartsWith", String)
def author_arg_starts_with(records, prefix):
return list(
filter(
lambda record: record.name.startswith(prefix),
records,
))
result = executor(Root)("""{ author(nameStartsWith: "P") { name } }""")
assert_that(
result,
is_successful_result(data={
"author": {
"name": "PG Wodehouse"
},
}))
def test_can_implement_graphql_core_interfaces():
HasName = GraphQLInterfaceType("HasName",
fields={
"name": GraphQLField(GraphQLString),
},
resolve_type=lambda: None)
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
class Author(StaticDataObjectType):
__interfaces__ = [HasName]
__records__ = [AuthorRecord("PG Wodehouse")]
name = field(type=String)
class Root(RootType):
author = single(lambda: StaticDataObjectType.select(Author))
result = executor(Root)("""{
author {
...on HasName {
name
}
}
}""")
assert_that(
result,
is_successful_result(data={
"author": {
"name": "PG Wodehouse"
},
}))
def test_interfaces_can_be_declared_using_function():
AuthorRecord = attr.make_class("AuthorRecord", ["name"])
class Author(StaticDataObjectType):
__interfaces__ = lambda: [HasName]
__records__ = [AuthorRecord("PG Wodehouse")]
name = field(type=String)
class HasName(InterfaceType):
name = field(type=String)
class Root(RootType):
author = single(lambda: StaticDataObjectType.select(Author))
result = executor(Root)("""{
author {
...on HasName {
name
}
}
}""")
assert_that(
result,
is_successful_result(data={
"author": {
"name": "PG Wodehouse"
},
}))
def __init__(
self,
name: str,
desc: str,
labels: Sequence[str],
sub_metrics: Sequence[str],
):
self.name = name
self.desc = desc
self.labels = labels
self.sub_metrics = sub_metrics
# Create a class which have the sub_metrics values as attributes, which
# default to 0 on initialization. Used to pass to registered callbacks.
self._metrics_class: Type[MetricsEntry] = attr.make_class(
"_MetricsEntry",
attrs={x: attr.ib(default=0) for x in sub_metrics},
slots=True,
)
# Counts number of in flight blocks for a given set of label values
self._registrations: Dict[
Tuple[str, ...], Set[Callable[[MetricsEntry], None]]
] = {}
# Protects access to _registrations
self._lock = threading.Lock()
self._register_with_collector()
def create_parameter_group(
config_dict_section: Union[dict, DictConfig]) -> ParameterGroupTypeVar:
"""
Creates a parameter group object out of a config_dict_section, which is a dictionary or DictConfig representing a
parameter group. This method should only be used for simple groups, i.e. parameter groups not containing any other
parameter groups. For nested groups, the function 'create_nested_parameter_group' should be used instead.
:param config_dict_section: Dictionary representation of the parameter group to construct
:return: ParameterGroup or ConfigurableParameters object constructed according to config_dict_section
"""
params_and_values = gather_parameter_arguments_and_values_from_dict(
config_dict_section)
make_arguments = params_and_values["make_arguments"]
call_arguments = params_and_values["call_arguments"]
all_parameter_values = params_and_values["values"]
group_type = str(config_dict_section.pop(metadata_keys.TYPE))
group_constructor_type = GroupElementMapping[group_type].value
group_constructor = attr.make_class(
GroupElementMapping[group_type].name,
bases=(group_constructor_type, ),
attrs=make_arguments,
eq=False,
order=False,
)
parameter_group = group_constructor(**call_arguments)
for parameter, value in all_parameter_values.items():
if value is not None:
setattr(parameter_group, parameter, value)
return parameter_group
def test_programmatic(self, slots, frozen):
"""
`attr.make_class` works.
"""
PC = attr.make_class("PC", ["a", "b"], slots=slots, frozen=frozen)
assert (
Attribute(
name="a",
default=NOTHING,
validator=None,
repr=True,
cmp=None,
eq=True,
order=True,
hash=None,
init=True,
),
Attribute(
name="b",
default=NOTHING,
validator=None,
repr=True,
cmp=None,
eq=True,
order=True,
hash=None,
init=True,
),
) == attr.fields(PC)
def __init__(self, name):
self.name = name
self.items = dict()
self.items["displayId"] = name
default_sha = "e685cbba9aab1683a4a504582b4e30af36cdfddb"
self.commit = attr.make_class("Commit",
{"sha": attr.ib(default=default_sha)})()
def grammar(self):
ret = dict()
@attr.s
class GrammarStub(object):
name = attr.ib()
grammar = attr.ib()
@classmethod
def make(cls, name, *a):
if isinstance(a[0], str):
ret[name] = re.compile(a[0])
return ret[name]
else:
self = cls(name, a)
ret[name] = self
return self
make = GrammarStub.make
lineSep = make("lineSep", b'\r')
lineSepLax = make("lineSepLax", b'\n')
segmentName = make("segmentName", '[a-zA-Z0-9_]+')
component = make("component", '.*?(?=[' + self.fieldSep + '])') # lookahead whee
Field = make("Field", component, pp_maybe_some(self.componentSep, component))
Segment = make("Segment", pp_attr('name', segmentName), pp_maybe_some(self.fieldSep, Field), lineSep) # fixme use ignore() on separators
MSH = make("MSH", pp_attr('name', MSH_SEGMENT), pp_maybe_some(self.fieldSep, Field), lineSep)
## InterfaceMessage = make("InterfaceMessage", START_BLOCK, MSH, lineSep, pp_maybe_some(Segment), END_BLOCK)
## InterfaceMessageLax = make("InterfaceMessageLax", MSH, lineSepLax, pp_maybe_some(Segment))
return attr.make_class(b"Grammar", ret.keys())(**ret)
def test_make_class_ordered(self):
"""
If `make_class()` is passed ordered attrs, their order is respected
instead of the counter.
"""
b = attr.ib(default=2)
a = attr.ib(default=1)
C = attr.make_class("C", ordered_dict([("a", a), ("b", b)]))
assert "C(a=1, b=2)" == repr(C())
def test_programmatic(self):
"""
`attr.make_class` works.
"""
PC = attr.make_class("PC", ["a", "b"])
assert (
Attribute(name="a", default=NOTHING, validator=None,
repr=True, cmp=True, hash=True, init=True),
Attribute(name="b", default=NOTHING, validator=None,
repr=True, cmp=True, hash=True, init=True),
) == attr.fields(PC)
def _convert(cls, result_cls, data):
try:
return result_cls(**data)
except TypeError:
try:
fields = [f.name for f in attr.fields(result_cls)]
return result_cls(**{
k: v
for k, v in data.items() if k in fields
})
except TypeError:
return attr.make_class("ApiResponse", list(data.keys()))(**data)
def make_attrs_class(typename, d):
import attr
vals = {}
for k, v in d.items():
if v[2] == float:
vals[k] = attr.ib(
default=v[0], validator=attr.validators.instance_of(v[2]))
else:
vals[k] = attr.ib(default=v[0])
C = attr.make_class(typename, vals)
return C()
def __init__(self, name, desc, labels, sub_metrics):
self.name = name
self.desc = desc
self.labels = labels
self.sub_metrics = sub_metrics
# Create a class which have the sub_metrics values as attributes, which
# default to 0 on initialization. Used to pass to registered callbacks.
self._metrics_class = attr.make_class(
"_MetricsEntry",
attrs={x: attr.ib(0) for x in sub_metrics},
slots=True,
)
# Counts number of in flight blocks for a given set of label values
self._registrations = {}
# Protects access to _registrations
self._lock = threading.Lock()
self._register_with_collector()
from . import load_tf_lib
from .cube_dim_transcoder import CubeDimensionTranscoder
from .staging_area_wrapper import create_staging_area_wrapper
from .sources import (SourceContext, DefaultsSourceProvider)
from .sinks import (SinkContext, NullSinkProvider)
from .start_context import StartContext
from .stop_context import StopContext
from .init_context import InitialisationContext
ONE_KB, ONE_MB, ONE_GB = 1024, 1024**2, 1024**3
QUEUE_SIZE = 10
rime = load_tf_lib()
DataSource = attr.make_class("DataSource", ['source', 'dtype', 'name'],
slots=True, frozen=True)
DataSink = attr.make_class("DataSink", ['sink', 'name'],
slots=True, frozen=True)
FeedOnce = attr.make_class("FeedOnce", ['ph', 'var', 'assign_op'],
slots=True, frozen=True)
class RimeSolver(MontblancTensorflowSolver):
""" RIME Solver Implementation """
def __init__(self, slvr_cfg):
"""
RimeSolver Constructor
Parameters:
slvr_cfg : SolverConfiguration
Solver Configuration variables
self.a = a
self.b = b
self.c = c
super(super_dumb_class, self).__init__(a=a, b=b, c=c)
return super_dumb_class
super_dumb_class = make_super_dumb_class()
class dumb_class(object):
def __init__(self, a, b, c="abc"):
self.a = a
self.b = b
self.c = c
namedtuple_class = namedtuple("namedtuple_class", ["a", "b", "c"])
attrs_class = make_class("attrs_class", ["a", "b", "c"])
def test_characteristic(benchmark):
assert benchmark(partial(characteristic_class, a=1, b=2, c=1))
def test_fields(benchmark):
assert benchmark(partial(fields_class, a=1, b=2, c=1))
def test_fields_nosuper(benchmark):
assert benchmark(partial(fields_nosuper_class, a=1, b=2, c=1))
def test_slots_fields(benchmark):
a_number = attr.ib(default=42)
list_of_numbers = attr.ib(default=attr.Factory(list))
def hard_math(self, another_number):
return self.a_number + sum(self.list_of_numbers) * another_number
sc = SomeClass(1, [1, 2, 3])
# sc
SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
sc.hard_math(3)
# 19
sc == SomeClass(1, [1, 2, 3])
# True
sc != SomeClass(2, [3, 2, 1])
# True
attr.asdict(sc)
# {'a_number': 1, 'list_of_numbers': [1, 2, 3]}
SomeClass()
SomeClass(a_number=42, list_of_numbers=[])
C = attr.make_class("C", ["a", "b"])
C("foo", "bar")
# C(a='foo', b='bar')
print("Finished...")
pass
@attr.s
@six.add_metaclass(Meta)
class WithMeta(object):
pass
@attr.s(slots=True)
@six.add_metaclass(Meta)
class WithMetaSlots(object):
pass
FromMakeClass = attr.make_class("FromMakeClass", ["x"])
class TestDarkMagic(object):
"""
Integration tests.
"""
@pytest.mark.parametrize("cls", [C2, C2Slots])
def test_fields(self, cls):
"""
`attr.fields` works.
"""
assert (
Attribute(name="x", default=foo, validator=None,
repr=True, cmp=True, hash=None, init=True),
Attribute(name="y", default=attr.Factory(list), validator=None,
