Exemplo n.º 1
0
 def test_dont_filter_out_non_recently_converged(self):
     """
     If a group was converged in the past but not recently, it will be
     cleaned from the ``recently_converged`` map, and it will be converged.
     """
     # g1: converged a while ago; divergent -> removed and converged
     # g2: converged recently; not divergent -> not converged
     # g3: converged a while ago; not divergent -> removed and not converged
     eff = self._converge_all_groups(['00_g1'])
     sequence = [
         (ReadReference(ref=self.currently_converging), lambda i: pset([])),
         (Log('converge-all-groups',
              dict(group_infos=[self.group_infos[0]],
                   currently_converging=[])),
          noop),
         (ReadReference(ref=self.recently_converged),
          lambda i: pmap({'g1': 4, 'g2': 10, 'g3': 0})),
         (Func(time.time), lambda i: 20),
         (ModifyReference(self.recently_converged,
                          match_func("literally anything",
                                     pmap({'g2': 10}))),
          noop),
         parallel_sequence([[self._expect_group_converged('00', 'g1')]])
     ]
     self.assertEqual(perform_sequence(sequence, eff), ['converged g1!'])
Exemplo n.º 2
0
def read_schedule_json(obj):
    # reconstruct schedule information from json
    agents = pvector(obj['agents'])
    costs = pmap(obj['costs'])
    times = pset(map(as_timerange,obj['times']))
    forward = pmap({a: pmap({as_timerange(t): int(t['mid'])
                             for t in obj['meetings'][a] if t['mid'] != -1})
                    for a in agents})

    mids = pset([mid for ts in forward.values() for mid in ts.values()])

    # remove the mid 0, which marks an empty meeting (for unavailable times)
    if 0 in mids:
      mids = mids.remove(0)

    # update meetings and their requirements
    requirements = pmap({int(mid): pmap({r['type']: read_jsonable_requirement(r)
                                        for r in rs.values()})
                         for mid,rs in obj['requirements'].iteritems()})

    schedule = Schedule(agents=agents,times=times,forward=forward,
                        requirements=requirements,costs=costs)

    new_unsatisfied = schedule.unsatisfied
    for mid,rs in schedule.unsatisfied.iteritems():
      for rtype in rs:
        r = schedule.requirements[mid][rtype]
        if r.satisfied(schedule):
          new_unsatisfied = _mark_satisfied(new_unsatisfied,r)
        elif not r.satisfiable(schedule):
          raise RequirementException(r)
    schedule.unsatisfied = new_unsatisfied

    return schedule
Exemplo n.º 3
0
def merge_results(results):
    """
    Given a list of dictionary results from episodes and the interesting keys, merge them into a single dictionary.
    Example: [{episode_id: 1, steps: 22}, {episode_id: 2, steps: 30}] -> {episode_id: [1, 2], steps: [22, 30]}
    """
    seed_dictionary = pmap({key: v() for key, _ in results[0].items()})
    return pmap(reduce(lambda result1, y: {key: value.append(y[key]) for key, value in result1.items()}, [seed_dictionary] + results))
Exemplo n.º 4
0
  def __init__(self,agents=pvector([]),times=pset([]),forward=pmap({}),
               costs=pmap({}),requirements=pmap({}),backward=None,
               unsatisfied=None):
    self.cache = {}

    #### schedule bounds
    self.agents = agents  # vector of valid agents
    self.times = times  # set of valid times

    #### the schedule itself
    self.forward = forward  # agents -> times -> meeting ids

    # mids -> meeting (time, agents)
    if backward is None: self.backward = _backward_from_forward(self.forward)
    else: self.backward = backward

    #### schedule constraints
    self.requirements = requirements  # mids -> requirement type -> requirement

    # mids -> requirement type
    if unsatisfied is None:
      self.unsatisfied = pmap({mid: pset(self.requirements[mid].keys())
                               for mid in self.requirements.keys()})
    else: self.unsatisfied = unsatisfied

    self.costs = costs  # map from agents to meeting time costs functions
Exemplo n.º 5
0
 def test_filters_clb_types(self):
     """
     Only one CLB step is returned per CLB
     """
     steps = pbag([
         AddNodesToCLB(
             lb_id='5',
             address_configs=s(('1.1.1.1',
                                CLBDescription(lb_id='5', port=80)))),
         RemoveNodesFromCLB(lb_id='5', node_ids=s('1')),
         # Unoptimizable step
         CreateServer(server_config=pmap({})),
     ])
     # returned steps could be pbag of any of the 2 lists below depending
     # on how `one_clb_step` iterates over the steps. Since it is pbag the
     # order of elements is not guaranteed
     list1 = [
         AddNodesToCLB(
             lb_id='5',
             address_configs=s(
                 ('1.1.1.1', CLBDescription(lb_id='5', port=80)))),
         CreateServer(server_config=pmap({}))
     ]
     list2 = [
         RemoveNodesFromCLB(lb_id='5', node_ids=s('1')),
         CreateServer(server_config=pmap({}))
     ]
     self.assertEqual(
         matches(MatchesAny(Equals(pbag(list1)), Equals(pbag(list2)))),
         optimize_steps(steps)
     )
Exemplo n.º 6
0
 def test_returns_new_pmap_given_pmap(self):
     """
     If a PMap is passed in, a new PMap is returned, and even the new value
     that was passed in gets frozen.
     """
     self.assertEquals(set_in(pmap({1: 2}), (1,), {1: 3}),
                       pmap({1: pmap({1: 3})}))
 def setUp(self):
     self.format = mock.MagicMock(return_value=lambda x: str(x))
     self.label_1 = "a"
     self.label_2 = "b"
     self.true_positive = 8
     self.true_negative = 8
     self.false_positive = 8
     self.false_negative = 8
     self.confusion_table = ConfusionTable(
         self.label_1,
         self.true_positive,
         self.true_negative,
         self.false_positive,
         self.false_negative,
         self.format
     )
     self.predictions = pmap({
         self.label_1: pmap({
             self.label_1: self.true_positive,
             self.label_2: self.false_positive,
         }),
         self.label_2: pmap({
             self.label_1: self.false_negative,
             self.label_2: self.true_negative
         })
     })
Exemplo n.º 8
0
def parse_file(excel_file):
  excel = pd.ExcelFile(excel_file)

  df = excel.parse('Schedule',index_col=0)
  df.columns = clean_up(df.columns)
  times,agents = parse_schedule(df)

  df = excel.parse('Meetings',index_col=None)
  df.columns = clean_up(df.columns)
  del df['area']
  df.name = clean_up(df.name)
  meetings = parse_student_meetings(df,3)

  offset = meetings[-1].mid+1
  df = excel.parse('Lab Meetings',index_col=None)
  df.columns = clean_up(df.columns)
  meetings += parse_lab_meetings(df,offset=offset)

  df = excel.parse('Schedule Preferences')
  df.columns = clean_up(df.columns)
  costs = parse_costs(df)

  final_meetings = {}
  for requirement in meetings:
    old = final_meetings.get(requirement.mid,pset())
    final_meetings[requirement.mid] = old.add(requirement)

  return Schedule(list(agents),pmap(),pmap(times),costs,
                  pmap(final_meetings),pmap())
Exemplo n.º 9
0
 def test_returns_new_pmap_given_dict(self):
     """
     If a dictionary is passed in, a new PMap is returned and the old
     dictionary is unaffected.
     """
     a = {1: 2}
     self.assertEquals(set_in(a, (1,), {1: 3}), pmap({1: pmap({1: 3})}))
     self.assertEquals(a, {1: 2})
Exemplo n.º 10
0
 def test_hash_parameters(self):
     self.assertEqual(
         {
             http.MediaRange(type="a", parameters=pmap({"a": "b"})),
             http.MediaRange(type="a", parameters=pmap({"a": "b"})),
         },
         {http.MediaRange(type="a", parameters=pmap({"a": "b"}))},
     )
Exemplo n.º 11
0
 def __init__(self, nodes=None, this_node_uuid=uuid4()):
     self._configured_datasets = pmap()
     self._configured_containers = pmap()
     self._leases = LeasesModel()
     if nodes is None:
         nodes = []
     self._nodes = nodes
     self._this_node_uuid = this_node_uuid
     self.synchronize_state()
Exemplo n.º 12
0
def test_equal_with_different_bucket_sizes():
    x = pmap({'a': 1, 'b': 2}, 50)
    y = pmap({'a': 1, 'b': 2}, 10)

    assert x == y
    assert not (x != y)

    assert y == x
    assert not (y != x)
Exemplo n.º 13
0
def test_set_with_relocation():
    x = pmap({'a':1000}, pre_size=1)
    x = x.set('b', 3000)
    x = x.set('c', 4000)
    x = x.set('d', 5000)
    x = x.set('d', 6000)

    assert len(x) == 4
    assert x == pmap({'a': 1000, 'b': 3000, 'c': 4000, 'd': 6000})
Exemplo n.º 14
0
def test_equal_with_different_insertion_order():
    x = pmap([(i, i) for i in range(50)], 10)
    y = pmap([(i, i) for i in range(49, -1, -1)], 10)

    assert x == y
    assert not (x != y)

    assert y == x
    assert not (y != x)
 def __get_basic_average_metrics(self):
     return pmap({
         "average": pmap({
             "accuracy": self.average_accuracy,
             "precision": self.average_precision,
             "recall": self.average_recall,
             "specificity": self.average_specificity,
             "f1score": self.average_f1score
         })
     })
Exemplo n.º 16
0
def test_evolver_update_with_relocation():
    x = pmap({'a':1000}, pre_size=1)
    e = x.evolver()
    e['b'] = 3000
    e['c'] = 4000
    e['d'] = 5000
    e['d'] = 6000

    assert len(e) == 4
    assert e.persistent() == pmap({'a': 1000, 'b': 3000, 'c': 4000, 'd': 6000})
 def log_metrics(self, log_level='basic'):
     avg_metrics_dict = pmap({
         "basic": self.__get_basic_average_metrics,
         "all": self.__get_all_average_metrics
     })[log_level]()
     metrics_dict = pmap({
         "basic": self.__get_basic_metrics_for_each_class,
         "all": self.__get_all_metrics_for_each_class
     })[log_level]()
     return self.__format_function(avg_metrics_dict), self.__format_function(metrics_dict)
 def __get_basic_metrics_for_class(confusion_table):
     return pmap({
         str(confusion_table.get_class_name()): pmap({
             "Accuracy": confusion_table.accuracy,
             "Precision": confusion_table.precision,
             "Recall": confusion_table.recall,
             "Specificity": confusion_table.specificity,
             "F1score": confusion_table.f1score
         })
     })
Exemplo n.º 19
0
def test_same_hash_when_content_the_same_but_underlying_vector_size_differs():
    x = pmap(dict((x, x) for x in range(1000)))
    y = pmap({10: 10, 200: 200, 700: 700})

    for z in x:
        if z not in y:
            x = x.remove(z)

    assert x == y
    assert hash(x) == hash(y)
Exemplo n.º 20
0
def compute_check_result_for_job(client, job):
    kwargs = m(
        name="check_tron_job.{}".format(job['name']),
        source="tron",
    )
    if 'realert_every' not in kwargs:
        kwargs = kwargs.set('realert_every', guess_realert_every(job))
    kwargs = kwargs.set('check_every', f"{_run_interval}s")

    # We want to prevent a monitoring config from setting the check_every
    # attribute, since one config should not dictate how often this script runs
    sensu_kwargs = (
        pmap(job['monitoring']).discard(PRECIOUS_JOB_ATTR)
        .discard('check_every')
    )
    kwargs = kwargs.update(sensu_kwargs)

    kwargs_list = []
    if job["status"] == "disabled":
        kwargs = kwargs.set(
            'output',
            "OK: {} is disabled and won't be checked.".format(job['name'], )
        )
        kwargs = kwargs.set('status', 0)
        kwargs_list.append(kwargs)
    else:
        # The job is not disabled, therefore we have to look at its run history
        url_index = client.index()
        tron_id = get_object_type_from_identifier(url_index, job["name"])
        job_content = pmap(
            client.job(
                tron_id.url,
                include_action_runs=True,
            )
        )

        if job['monitoring'].get(PRECIOUS_JOB_ATTR, False):
            dated_runs = sort_runs_by_interval(job_content, interval='day')
        else:
            dated_runs = {'': job_content['runs']}

        for date, runs in dated_runs.items():
            results = compute_check_result_for_job_runs(
                job=job,
                job_content=job_content.set('runs', runs),
                client=client,
            )
            dated_kwargs = kwargs.update(results)
            if date:  # if empty date, leave job name alone
                dated_kwargs = dated_kwargs.set(
                    'name', f"{kwargs['name']}-{date}"
                )
            kwargs_list.append(dated_kwargs)

    return [dict(kws) for kws in kwargs_list]
Exemplo n.º 21
0
 def __str__(self):
     """
         Returns ConfusionTable instance as a Grid
     """
     table_values = pmap({
         "true_positive": pmap({str(self.__class_name): self.__true_positive}),
         "true_negative": pmap({str(self.__class_name): self.__true_negative}),
         "false_positive": pmap({str(self.__class_name): self.__false_positive}),
         "false_negative": pmap({str(self.__class_name): self.__false_negative})
     })
     return self.__format_function(table_values).__str__()
Exemplo n.º 22
0
    def test_mixed_optimization(self):
        """
        Mixes of optimizable and unoptimizable steps still get optimized
        correctly.
        """
        steps = pbag([
            # CLB adds
            AddNodesToCLB(
                lb_id='5',
                address_configs=s(('1.1.1.1',
                                   CLBDescription(lb_id='5', port=80)))),
            AddNodesToCLB(
                lb_id='5',
                address_configs=s(('1.1.1.2',
                                   CLBDescription(lb_id='5', port=80)))),
            AddNodesToCLB(
                lb_id='6',
                address_configs=s(('1.1.1.1',
                                   CLBDescription(lb_id='6', port=80)))),
            AddNodesToCLB(
                lb_id='6',
                address_configs=s(('1.1.1.2',
                                   CLBDescription(lb_id='6', port=80)))),
            RemoveNodesFromCLB(lb_id='5', node_ids=s('1')),
            RemoveNodesFromCLB(lb_id='5', node_ids=s('2')),
            RemoveNodesFromCLB(lb_id='6', node_ids=s('3')),
            RemoveNodesFromCLB(lb_id='6', node_ids=s('4')),

            # Unoptimizable steps
            CreateServer(server_config=pmap({})),
        ])

        self.assertEqual(
            optimize_steps(steps),
            pbag([
                # Optimized CLB adds
                AddNodesToCLB(
                    lb_id='5',
                    address_configs=s(('1.1.1.1',
                                       CLBDescription(lb_id='5', port=80)),
                                      ('1.1.1.2',
                                       CLBDescription(lb_id='5', port=80)))),
                AddNodesToCLB(
                    lb_id='6',
                    address_configs=s(('1.1.1.1',
                                       CLBDescription(lb_id='6', port=80)),
                                      ('1.1.1.2',
                                       CLBDescription(lb_id='6', port=80)))),
                RemoveNodesFromCLB(lb_id='5', node_ids=s('1', '2')),
                RemoveNodesFromCLB(lb_id='6', node_ids=s('3', '4')),

                # Unoptimizable steps
                CreateServer(server_config=pmap({}))
            ]))
Exemplo n.º 23
0
 def test_transform_empty_path(self):
     """
     If ``transform`` is supplied with an empty path, the operation is
     performed on the root object.
     """
     proxy = _TransformProxy(pmap({'a': 1}))
     proxy.transform([], lambda o: o.set('a', 2))
     self.assertEqual(
         pmap({'a': 2}),
         proxy.commit(),
     )
Exemplo n.º 24
0
 def test_create_server(self):
     """
     :obj:`CreateServer.as_request` produces a request for creating a server.
     """
     create = CreateServer(launch_config=pmap({'name': 'myserver', 'flavorRef': '1'}))
     self.assertEqual(
         create.as_request(),
         Request(
             service=ServiceType.CLOUD_SERVERS,
             method='POST',
             path='servers',
             data=pmap({'name': 'myserver', 'flavorRef': '1'})))
Exemplo n.º 25
0
 def test_generator_returns_confusion_table_correctly_with_two_classes(self):
     predictions = pmap({
         self.label_1: pmap({
             self.label_1: self.true_positive,
             self.label_2: self.false_positive,
         }),
         self.label_2: pmap({
             self.label_1: self.false_negative,
             self.label_2: self.true_negative
         })
     })
     confusion_table = generate_confusion_table(predictions, self.label_1, format_dict_as_grid)
     self.failUnlessEqual(self.ct.__str__(), confusion_table.__str__())
Exemplo n.º 26
0
 def test_from_dict(self):
     """
     L{WrittenMessage.from_dict} converts a dictionary that has been
     deserialized from a log into a L{WrittenMessage} object.
     """
     log_entry = pmap(
         {"timestamp": 1, "task_uuid": "unique", "task_level": [1], "foo": "bar"}
     )
     parsed = WrittenMessage.from_dict(log_entry)
     self.assertEqual(parsed.timestamp, 1)
     self.assertEqual(parsed.task_uuid, "unique")
     self.assertEqual(parsed.task_level, TaskLevel(level=[1]))
     self.assertEqual(parsed.contents, pmap({"foo": "bar"}))
Exemplo n.º 27
0
Arquivo: utils.py Projeto: glyph/otter
def server(id, state, created=0, image_id='image', flavor_id='flavor',
           json=None, metadata=pmap(), **kwargs):
    """Convenience for creating a :obj:`NovaServer`."""
    json = pmap(json) or pmap({'id': id, 'status': state.name})
    if state is ServerState.UNKNOWN_TO_OTTER:
        json = json.set('status', 'blargho')
    elif state is ServerState.DELETED:
        json = json.set('status', 'ACTIVE')
        json = json.set('OS-EXT-STS:task_state', 'deleting')
    if metadata:
        json = json.set('metadata', pmap(metadata))
    return NovaServer(id=id, state=state, created=created, image_id=image_id,
                      flavor_id=flavor_id,
                      json=json, **kwargs)
Exemplo n.º 28
0
 def test_converge_give_me_multiple_servers(self):
     """
     Multiple servers are added at a time if there are not enough servers to
     meet the desired capacity.
     """
     self.assertEqual(
         converge(
             DesiredGroupState(server_config={}, capacity=2),
             set(),
             set(),
             0),
         pbag([
             CreateServer(server_config=pmap()),
             CreateServer(server_config=pmap())]))
Exemplo n.º 29
0
def run_multiple_inserts_in_pmap():
    from pyrsistent import pmap

    COUNT = 100000
    def test_range():
        prime = 317
        return range(0, prime*COUNT, prime)

    elements = {x: x for x in test_range()}

    # Using ordinary set
    start = time.time()
    m1 = pmap(elements)
    print("Done initalizing, time=%s s, count=%s" % (time.time() - start, COUNT))


    start = time.time()
    m2 = pmap()
    for x in test_range():
        m2 = m2.set(x, x)
    print("Done setting, time=%s s, count=%s" % (time.time() - start, COUNT))

    assert m1 == m2

    start = time.time()
    m3 = pmap()
    e3 = m3.evolver()
    for x in test_range():
        e3[x] = x
    m3 = e3.persistent()
    print("Done evolving, time=%s s, count=%s" % (time.time() - start, COUNT))

    assert m3 == m2

    start = time.time()
    m4 = pmap()
    m4 = m4.update(elements)
    m4 = m4.update(elements)
    print("Done updating, time=%s s, count=%s" % (time.time() - start, COUNT))

    assert m4 == m3

    start = time.time()
    m5 = pmap()
    m5 = m5.update_with(lambda l, r: r, elements)
    m5 = m5.update_with(lambda l, r: r, elements)
    print("Done updating with, time=%s s, count=%s" % (time.time() - start, COUNT))

    assert m5 == m4
Exemplo n.º 30
0
 def test_converge_give_me_multiple_servers(self):
     """
     Multiple servers are added at a time if there are not enough servers to
     meet the desired capacity.
     """
     self.assertEqual(
         converge(
             DesiredGroupState(launch_config={}, desired=2),
             [],
             {},
             0),
         Convergence(
             steps=pbag([
                 CreateServer(launch_config=pmap()),
                 CreateServer(launch_config=pmap())])))
Exemplo n.º 31
0
 def __init__(
     self,
     typ: t.Type[iface.IType],
     attrs: t.Sequence[str] = pvector([]),
     deserialize_overrides: PMap[str, str] = pmap({}),
     unknown: str = 'ignore',
 ) -> None:
     """
     :param deserialize_overrides: source_field_name => struct_field_name mapping
     """
     super().__init__(unknown)
     self.typ = typ
     self.attrs = attrs
     self.deserialize_overrides = deserialize_overrides
     # struct_field_name => source_field_name
     self.serialize_overrides = pmap(
         {v: k
          for k, v in self.deserialize_overrides.items()})
Exemplo n.º 32
0
 def __setstate__(self, d):
     dat = d['data']
     object.__setattr__(
         self, 'data',
         ps.pmap({
             k: (imm_array(u) if v is None else iquant(u, v))
             for (k, (u, v)) in six.iteritems(dat)
         }))
     object.__setattr__(self, '_row_count', None)
Exemplo n.º 33
0
def test_initialization_with_two_elements():
    map = pmap({'a': 2, 'b': 3})
    assert len(map) == 2
    assert map['a'] == 2
    assert map['b'] == 3

    map2 = map.remove('a')
    assert 'a' not in map2
    assert map2['b'] == 3
Exemplo n.º 34
0
class _Directory(object):
    """
    A directory.
    """

    _name = attr.ib()
    _parent = attr.ib(repr=False)
    _children = attr.ib(default=pmap())

    @classmethod
    def root(cls):
        root = cls(name="", parent=None)
        root._parent = root
        return root

    def __getitem__(self, name):
        return self._children.get(
            name,
            _DirectoryChild(name=name, parent=self),
        )

    def __setitem__(self, name, node):
        self._children = self._children.set(name, node)

    def __delitem__(self, name):
        self._children = self._children.remove(name)

    def create_directory(self, path, with_parents):
        raise exceptions.FileExists(path)

    def list_directory(self, path):
        return pset(self._children)

    def remove_empty_directory(self, path):
        if self._children:
            raise exceptions.DirectoryNotEmpty(path)
        del self._parent[self._name]

    def create_file(self, path):
        raise exceptions.FileExists(path)

    def open_file(self, path, mode):
        raise exceptions.IsADirectory(path)

    def remove_file(self, path):
        raise exceptions._UnlinkNonFileError(path)

    def link(self, source, to, fs, state):
        raise exceptions.FileExists(to)

    def readlink(self, path):
        raise exceptions.NotASymlink(path)

    def stat(self, path):
        return os.stat_result((stat.S_IFDIR, ) + (0, ) * 9)

    lstat = stat
Exemplo n.º 35
0
 def __add__(self, other_pde):
     assert self.dim == other_pde.dim
     res = dict(self.mi_to_coeff)
     for k, v in other_pde.mi_to_coeff.items():
         if k in res:
             res[k] += v
         else:
             res[k] = v
     return DifferentialOperator(self.dim, pmap(res))
Exemplo n.º 36
0
def laplacian(diff_op):
    dim = diff_op.dim
    empty = [pmap()] * len(diff_op.eqs)
    res = LinearPDESystemOperator(dim, *empty)
    for j in range(dim):
        mi = [0]*diff_op.total_dims
        mi[j] = 2
        res = res + diff(diff_op, tuple(mi))
    return res
Exemplo n.º 37
0
 def __init__(self, initial=None):
     # type: (Optional[Mapping[KT, VT]]) -> None
     self.__parent = None  # type: Optional[WeakReference[Storage[KT, VT]]]
     self.__storages = WeakSet({self})  # type: MutableSet[Storage[KT, VT]]
     self.__data = cast(
         "PMapEvolver[WeakReference[KT], VT]",
         pmap().evolver())  # type: PMapEvolver[WeakReference[KT], VT]
     if initial is not None:
         self.__initialize(initial)
Exemplo n.º 38
0
def _typed_pmap_converter(
    init_val: typing.Mapping[str, typing.Callable[["TypeChecker", typing.Any],
                                                  bool], ],
) -> typing.Mapping[str, typing.Callable[["TypeChecker", typing.Any], bool]]:
    return typing.cast(
        typing.Mapping[str, typing.Callable[["TypeChecker", typing.Any],
                                            bool], ],
        pmap(init_val),
    )
Exemplo n.º 39
0
 def test_lt_parameters_same_type_and_subtype(self):
     self.assertLess(
         http.MediaRange(type="bar", subtype="foo"),
         http.MediaRange(
             type="bar",
             subtype="foo",
             parameters=pmap({"a": "b"}),
         ),
     )
Exemplo n.º 40
0
 def _load(res):
     flnm = HCPRetinotopyDataset.retinotopy_files[res]
     flnm = pseudo_path.local_path(flnm)
     logging.info(
         'HCPRetinotopyDataset: Loading subjects from file %s...' %
         flnm)
     with h5py.File(flnm, 'r') as f:
         sids = np.array(f['subjectids'][0], dtype='int')
     return pyr.pmap({sid: ii for (ii, sid) in enumerate(sids)})
Exemplo n.º 41
0
def test_pmap_field_optional():
    """
    If ``optional`` argument is true, ``None`` is acceptable alternative
    to a set.
    """
    class Record(PRecord):
        value = pmap_field(int, int, optional=True)
    assert (Record(value={1: 2}).value, Record(value=None).value) == \
           (pmap({1: 2}), None)
Exemplo n.º 42
0
 def test_no_clb_steps(self):
     """
     Returns same steps when there are no CLB steps passed
     """
     steps = [
         CreateServer(server_config=pmap({"name": "server"})),
         DeleteServer(server_id="abc")
     ]
     self.assertEqual(list(one_clb_step(steps)), steps)
Exemplo n.º 43
0
def reducer(action, state=pmap({})):

    if action.type == initial_action_type:
        new_state = pmap({'count': 0})
        return new_state
    if isinstance(action, INC_COUNTER):
        new_state = state.set('count', state['count'] + 1)
        return new_state
    if isinstance(action, DEC_COUNTER):
        new_state = state.set('count', state['count'] - 1)
        return new_state
    if isinstance(action, SET_COUNTER):
        new_state = state.set('count', action.payload)
        return new_state
    if isinstance(action, ADD_COUNTER):
        new_state = state.set('count', state['count'] + action.payload)
        return new_state
    return state
Exemplo n.º 44
0
    def _make(cls, internal=pmap()):
        # type: (Type[_DS], PMap[KT, VT]) -> _DS
        """
        Make new state by directly setting the internal state.

        :param internal: Internal state.
        :return: State.
        """
        return super(DictState, cls)._make(internal)
Exemplo n.º 45
0
    def test_normal_use(self):
        """Tests normal usage."""

        stack_config = pmap({'stack_name': 'baz', 'foo': 'bar'})
        new_stack_config = pmap({'stack_name': 'baz_foo', 'foo': 'bar'})

        self.create = CreateStack(stack_config)
        self.seq = [
            (Func(uuid4), lambda _: 'foo'),
            (create_stack(thaw(new_stack_config)).intent,
             lambda _: (StubResponse(200, {}), {'stack': {}})),
            (Log('request-create-stack', ANY), lambda _: None)
        ]

        reason = 'Waiting for stack to create'
        result = perform_sequence(self.seq, self.create.as_effect())
        self.assertEqual(result,
                         (StepResult.RETRY, [ErrorReason.String(reason)]))
Exemplo n.º 46
0
    def create_directory(self, path):
        if self.exists(path=path):
            raise exceptions.FileExists(path)

        parent = path.parent()
        if not self.exists(path=parent):
            raise exceptions.FileNotFound(parent)

        self._tree = self._tree.set(path, pmap())
Exemplo n.º 47
0
def diff(diff_op, mi):
    eqs = []
    for eq in diff_op.eqs:
        res = {}
        for deriv_ident, v in eq.items():
            new_mi = add_mi(deriv_ident.mi, mi)
            res[DerivativeIdentifier(new_mi, deriv_ident.vec_idx)] = v
        eqs.append(pmap(res))
    return LinearPDESystemOperator(diff_op.dim, *eqs)
Exemplo n.º 48
0
 def test_as_dict(self):
     """
     L{WrittenMessage.as_dict} returns the dictionary that will be serialized
     to the log.
     """
     log_entry = pmap(
         {"timestamp": 1, "task_uuid": "unique", "task_level": [1], "foo": "bar"}
     )
     self.assertEqual(WrittenMessage.from_dict(log_entry).as_dict(), log_entry)
Exemplo n.º 49
0
async def get_balances_ftx(
    client: ntypes.CLIENT,
    symbols_resp: NoobitResponseSymbols,
    #  prevent unintentional passing of following args
    *,
    logger: typing.Optional[typing.Callable] = None,
    auth=FtxAuth(),
    base_url: pydantic.AnyHttpUrl = endpoints.FTX_ENDPOINTS.private.url,
    endpoint: str = endpoints.FTX_ENDPOINTS.private.endpoints.balances,
) -> Result[NoobitResponseBalances, pydantic.ValidationError]:

    asset_from_exchange = lambda x: {v: k for k, v in symbols_resp.assets.items()}[x]

    req_url = "/".join([base_url, "wallet", "balances"])
    method = "GET"
    headers = auth.headers(method, "/api/wallet/balances")

    valid_ftx_req = Ok(FtxPrivateRequest())

    result_content = await get_result_content_from_req(
        client, method, req_url, valid_ftx_req.value, headers
    )
    if isinstance(result_content, Err):
        return result_content

    valid_result_content = _validate_data(
        FtxResponseBalances, pmap({"balances": result_content.value})
    )
    if valid_result_content.is_err():
        return valid_result_content

    parsed_result_balances = parse_result(valid_result_content.value)

    valid_parsed_response_data = _validate_data(
        NoobitResponseBalances,
        pmap(
            {
                "balances": parsed_result_balances,
                "rawJson": result_content.value,
                "exchange": "FTX",
            }
        ),
    )
    return valid_parsed_response_data
Exemplo n.º 50
0
    def __init__(self, log, dispatcher, num_buckets, partitioner_factory,
                 build_timeout, interval,
                 limited_retry_iterations, step_limits,
                 converge_all_groups=converge_all_groups):
        """
        :param log: a bound log
        :param dispatcher: The dispatcher to use to perform effects.
        :param int buckets: the number of logical `buckets` which are be
            shared between all Otter nodes running this service. The buckets
            will be partitioned up between nodes to detirmine which nodes
            should work on which groups.
        :param partitioner_factory: Callable of (all_buckets, log, callback)
            which should create an :obj:`Partitioner` to distribute the
            buckets.
        :param number build_timeout: number of seconds to wait for servers to
            be in building before it's is timed out and deleted
        :param interval: Interval between convergence steps, per group.
        :param callable converge_all_groups: like :func:`converge_all_groups`,
            to be used for test injection only
        :param int limited_retry_iterations: number of iterations to wait for
            LIMITED_RETRY steps
        :param dict step_limits: Mapping of step name to number of executions
            allowed in a convergence cycle
        """
        MultiService.__init__(self)
        self.log = log.bind(otter_service='converger')
        self._dispatcher = dispatcher
        self._buckets = range(num_buckets)
        self.partitioner = partitioner_factory(
            buckets=self._buckets, log=self.log,
            got_buckets=self.buckets_acquired)
        self.partitioner.setServiceParent(self)
        self.build_timeout = build_timeout
        self._converge_all_groups = converge_all_groups
        self.interval = interval
        self.limited_retry_iterations = limited_retry_iterations
        self.step_limits = get_step_limits_from_conf(step_limits)

        # ephemeral mutable state
        self.currently_converging = Reference(pset())
        self.recently_converged = Reference(pmap())
        # Groups we're waiting on temporarily, and may give up on.
        self.waiting = Reference(pmap())  # {group_id: num_iterations_waited}
Exemplo n.º 51
0
def get_setting(settings: Settings, guild_id: Guild_id, key: str, f=None, default=None) -> Optional[str]:
    value = settings.get(guild_id, pmap()).get(key)

    if value is None:
        return default

    if f is not None:
        return f(value)

    return value
Exemplo n.º 52
0
Arquivo: ecs.py Projeto: arakhmat/ecs
def get_component(
        *, ecdb: EntityComponentDatabase[ComponentTemplate], entity: Entity,
        component_type: Type[ComponentTemplate]
) -> Optional[ComponentTemplate]:

    entities = ecdb._entities  # pylint: disable=protected-access
    entity_components = entities.get(entity, pyrsistent.pmap())
    component = entity_components.get(component_type)

    return component
Exemplo n.º 53
0
def test_dict_comprehension():
    "Test that {a:b for a, b in ...} is translated to a pmap."

    subject = funcs.dict_comprehension
    print(subject.__source__)

    actual = subject({'a': 'b', 'c': 'd'})

    assert isinstance(actual, PMap)
    assert actual == pmap({'b': 'a', 'e': 'f'})
Exemplo n.º 54
0
 def filters(fs):
     '''
     parser.filters is a dictionary of filter functions for the various entries in the given
     parser's command line arguments. See also help(CommandLineParser).
     '''
     if not fs: return pyr.m()
     if not is_map(fs):
         raise ValueError(
             'filters must be a mapping of entries to functions.')
     return pyr.pmap(fs)
Exemplo n.º 55
0
def _(action, state):
    # { 'id' : id, 'state': "done|active", 'todo': "" }

    next_seq = state['seq'] + 1
    return state.transform(['seq'], next_seq, ['todos', next_seq],
                           pmap({
                               'id': next_seq,
                               'todo': action.payload,
                               'state': 'active'
                           }))
Exemplo n.º 56
0
 def test_movable_from(self):
     square = v(0, 3)
     reachable = {v(0, 0), v(0, 7)}
     capturable = {v(0, 0), v(7, 7)}
     piece = Piece(reachable=reachable, capturable=capturable)
     board = core.Board(pieces=pmap({square: core.WHITE.piece(piece)}))
     self.assertEqual(
         sorted(board.movable_from(square=square)),
         [v(0, 0), v(0, 7), v(7, 7)],
     )
Exemplo n.º 57
0
def calc_contrast_energies(contrast_filter, divisive_normalization_function,
                           divisive_normalization_parameters,
                           cpd_sensitivities):
    '''
    calc_contrast_energies is a calculator that performs divisive normalization on the filtered
    contrast images and yields a nested map of contrast energy arrays; contrast_energies map has
    keys that are spatial frequencies (in cycles per degree) and whose values are maps; these maps
    have keys that are parameter value maps and whose values are the 3D contrast energy arrays.

    Required afferent parameters:
      * contrast_filter
      * divisive_normalization_function, divisive_normalization_parameters
      * cpd_sensitivities

    Output efferent values:
      @ contrast_energies Will be a nested map whose first level of keys are persistent-maps of the
        divisive normalization parameters and whose second level of keys are a set of frequencies;
        the values at the second level are the stacks of contrast energy images for the particular
        divisive normalization parameters and frequencies specified in the keys.
    '''
    # first, calculate the contrast energies at each frequency for all images then we combine them;
    # since this reuses images internally when the parameters are the same, it shouldn't be too
    # inefficient:
    divnfn = divisive_normalization_function
    params = divisive_normalization_parameters
    all_cpds = np.unique([
        k.to(units.cycle / units.deg).m if pimms.is_quantity(k) else k
        for s in cpd_sensitivities for k in s.iterkeys()
    ])
    all_cpds = all_cpds * (units.cycles / units.degree)
    rsps = {
        cpd: vw.contrast_energy
        for cpd in all_cpds for vw in
        [ImageArrayContrastView(contrast_filter, cpd, divnfn, params)]
    }
    # flip this around...
    flip = {}
    for (k0, v0) in rsps.iteritems():
        for (k1, v1) in v0.iteritems():
            if k1 not in flip: flip[k1] = {}
            flip[k1][k0] = v1
    rsps = pyr.pmap({k: pyr.pmap(v) for (k, v) in flip.iteritems()})
    return {'contrast_energies': rsps}
Exemplo n.º 58
0
def typing(e, extenv):
    visitor = Visitor(extenv)
    try:
        unify(types.Unit, visitor.visit(pmap(), e))
    except UnifyError:
        raise ValueError("top level does not have type unit")

    for name, t in extenv.items():
        extenv[name] = deref_typ(t)
    deref_term(e)
Exemplo n.º 59
0
def _combine_details(detailses):
    """
    Take a sequence of details dictionaries and combine them into one.
    """
    # XXX: Only necessary becaause testtools's `gather_details` is perversely
    # mutatey.
    result = {}
    for details in detailses:
        gather_details(details, result)
    return pmap(result)
Exemplo n.º 60
0
def _when_i_apply_a_new_state_changing_domain_event_to_the_aggregate(context):
    context.event = Event.generate('EventHappened')
    _key = context.expected_state_key = 'hello'
    _value = context.expected_state_value = 'world'
    apply_map = pmap({
        'EventHappened':
        lambda agg, *a, **kw: agg.set_state(_key, _value)
    })
    context.aggregate = context.aggregate.apply_event(context.event,
                                                      apply_map=apply_map)