Esempio n. 1
0
class Node(object):
    def __init__(self, node_dict):
        self.data = Subject()
        self.attrs = node_dict

    def send_to(self, to_node):
        self.data.subscribe(to_node.on_data)

    def compute_output(self, data):
        return self.transform(data, self.attrs.get('transformAttributes', {}))

    def set_transform(self, transform):
        self.transform = transform
        if self._data is not None:
            self.data.on_next(self.compute_output(self._data))

    @staticmethod
    def create(node_dict):
        from .data import DataNode
        from .transform import TransformNode
        from .sink import SinkNode

        node_type_map = {
            'DATA_NODE': DataNode,
            'TRANSFORM_NODE': TransformNode,
            'SINK_NODE': SinkNode
        }

        node_type = node_dict['nodeType']
        return node_type_map[node_type](node_dict)
Esempio n. 2
0
class WSHandler(WebSocketHandler):
    def open(self):
        print("WebSocket opened")

        # A Subject is both an observable and observer, so we can both subscribe
        # to it and also feed (on_next) it with new values
        self.stream = Subject()

        # Get all distinct key up events from the input and only fire if long enough and distinct
        query = (
            self.stream.map(lambda x: x["term"])
            .filter(lambda text: len(text) > 2)  # Only if the text is longer than 2 characters
            .debounce(0.750, scheduler=scheduler)  # Pause for 750ms
            .distinct_until_changed()
        )  # Only if the value has changed

        searcher = query.flat_map_latest(search_wikipedia)

        def send_response(x):
            self.write_message(x.body)

        def on_error(ex):
            print(ex)

        searcher.subscribe(send_response, on_error)

    def on_message(self, message):
        obj = json_decode(message)
        self.stream.on_next(obj)

    def on_close(self):
        print("WebSocket closed")
Esempio n. 3
0
def test_accepts_multiple_subscription_fields_defined_in_schema():
    SubscriptionTypeMultiple = GraphQLObjectType(
        name='Subscription',
        fields=OrderedDict([
            ('importantEmail', GraphQLField(EmailEventType)),
            ('nonImportantEmail', GraphQLField(EmailEventType)),
        ])
    )
    test_schema = GraphQLSchema(
        query=QueryType,
        subscription=SubscriptionTypeMultiple
    )

    stream = Subject()
    send_important_email, subscription = create_subscription(
        stream, test_schema)

    email = Email(
        from_='*****@*****.**',
        subject='Alright',
        message='Tests are good',
        unread=True,
    )
    l = []
    stream.subscribe(l.append)
    send_important_email(email)
    assert l[0][0] == email
Esempio n. 4
0
class WSHandler(WebSocketHandler):
    def open(self):
        print("WebSocket opened")

        # A Subject is both an observable and observer, so we can both subscribe
        # to it and also feed (on_next) it with new values
        self.subject = Subject()

        # Now we take on our magic glasses and project the stream of bytes into
        # a ...
        query = self.subject.map(
                lambda obj: obj["keycode"] # 1. stream of keycodes
            ).window_with_count(
                10, 1 # 2. stream of windows (10 ints long)
            ).select_many(
                # 3. stream of booleans, True or False
                lambda win: win.sequence_equal(codes)
            ).filter(
                lambda equal: equal # 4. stream of Trues
            )
        # 4. we then subscribe to the Trues, and signal Konami! if we see any
        query.subscribe(lambda x: self.write_message("Konami!"))

    def on_message(self, message):
        obj = json_decode(message)
        self.subject.on_next(obj)

    def on_close(self):
        print("WebSocket closed")
Esempio n. 5
0
class WSSubject(Observer):
    def __init__(self, web_socket: WebSocketResponse):
        super(WSSubject, self).__init__()
        self._web_socket = web_socket
        self._push_subject = Subject()

    def to_observable(self):
        return self._push_subject

    async def process(self):
        async for msg in self._web_socket:
            self._push_subject.on_next(msg)

        self._push_subject.on_completed()

    def on_next(self, data):
        self._web_socket.send_str(data)

    def on_completed(self):
        # close web socket
        # has to be coroutine to close ws
        pass

    def on_error(self, error):
        # send error and close web socket
        pass
Esempio n. 6
0
class PausableObservable(ObservableBase):
    def __init__(self, source, pauser=None):
        self.source = source
        self.controller = Subject()

        if pauser and hasattr(pauser, "subscribe"):
            self.pauser = self.controller.merge(pauser)
        else:
            self.pauser = self.controller

        super(PausableObservable, self).__init__()

    def _subscribe_core(self, observer):
        conn = self.source.publish()
        subscription = conn.subscribe(observer)
        connection = [Disposable.empty()]

        def on_next(b):
            if b:
                connection[0] = conn.connect()
            else:
                connection[0].dispose()
                connection[0] = Disposable.empty()

        pausable = self.pauser.distinct_until_changed().subscribe(on_next)
        return CompositeDisposable(subscription, connection[0], pausable)

    def pause(self):
        self.controller.on_next(False)

    def resume(self):
        self.controller.on_next(True)
Esempio n. 7
0
def setup_streams(store, debug=False):
    reducer = reduce_action

    if debug:
        reducer = debug_reducer(print_traceback=False)(reducer)

    action_stream = Subject() \
        .merge(*state_mutating_actions) \
        .map(partial(resolve_action, store=store)) \
        .filter(lambda action: action is not None) \
        .map(lambda action: reducer(store.value, action))
    action_stream.subscribe(store)

    changed_notes_stream = store \
        .map(selectors.current_note) \
        .distinct_until_changed() \
        .debounce(1000, scheduler=scheduler) \
        .pausable_buffered(note_ready_stream)
    changed_notes_stream.subscribe(do_save_note)

    ui_state_stream = store \
        .map(selectors.ui_state) \
        .debounce(500, scheduler=scheduler) \
        .distinct_until_changed()
    ui_state_stream.subscribe(save_ui_state)

    actions.quit.subscribe(do_quit)
Esempio n. 8
0
    def get_subject(self):
        subject = Subject()

        subject.subscribe(
            self.on_next,
            self.on_error,
            self.on_completed
        )

        return subject
Esempio n. 9
0
def build_threads(stream_to_testers, thread_target=_perform_subscribe):
    threads = []

    for stream, testers in stream_to_testers.items():
        subject = Subject()
        for tester in testers:
            subject.subscribe(tester)

        threads.append(_make_thread(thread_target, stream, subject))

    return threads
Esempio n. 10
0
class Pirs:
    def __init__(self):
        io.setmode(io.BCM)
        self.pir_pin = 4
        io.setup(self.pir_pin, io.IN)
        self.pirStream = Subject()
        io.add_event_detect(self.pir_pin, io.RISING, callback=self.hit_callback)

    def hit_callback(self, channel):
        logger.logger.debug('PIR DETECTION!')
        self.pirStream.on_next(True)
Esempio n. 11
0
class Window(Gtk.Window):
    def __init__(self):
        super().__init__()
        self.resize(600, 600)

        self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
        self.connect("motion-notify-event", self.on_mouse_move)

        self.mousemove = Subject()

    def on_mouse_move(self, widget, event):
        self.mousemove.on_next((event.x, event.y))
Esempio n. 12
0
            def on_next_left(value):
                s = Subject()

                with self.lock:
                    _id = left_id[0]
                    left_id[0] += 1
                    left_map[_id] = s

                try:
                    result = result_selector(value, add_ref(s, r))
                except Exception as e:
                    log.error("*** Exception: %s" % e)
                    for left_value in left_map.values():
                        left_value.on_error(e)

                    observer.on_error(e)
                    return

                observer.on_next(result)

                for right_value in right_map.values():
                    s.on_next(right_value)

                md = SingleAssignmentDisposable()
                group.add(md)

                def expire():
                    if _id in left_map:
                        del left_map[_id]
                        s.on_completed()

                    group.remove(md)

                try:
                    duration = left_duration_selector(value)
                except Exception as e:
                    for left_value in left_map.values():
                        left_value.on_error(e)

                    observer.on_error(e)
                    return

                def on_error(e):
                    for left_value in left_map.values():
                        left_value.on_error(e)

                    observer.on_error(e)

                md.disposable = duration.take(1).subscribe(
                    nothing,
                    on_error,
                    expire)
Esempio n. 13
0
                def action(scheduler, state=None):
                    s = None

                    if is_shift:
                        s = Subject()
                        q.append(s)
                        observer.on_next(add_ref(s, ref_count_disposable))

                    if is_span:
                        s = q.pop(0)
                        s.on_completed()

                    create_timer()
Esempio n. 14
0
class Window(QWidget):

    def __init__(self):
        super(QWidget, self).__init__()
        self.setWindowTitle("Rx for Python rocks")
        self.resize(600, 600)
        self.setMouseTracking(True)

        # This Subject is used to transmit mouse moves to labels
        self.mousemove = Subject()

    def mouseMoveEvent(self, event):
        self.mousemove.on_next((event.x(), event.y()))
Esempio n. 15
0
class Frame(wx.Frame):

    def __init__(self):
        super(Frame, self).__init__(None)
        self.SetTitle("Rx for Python rocks")
        self.SetSize((600, 600))

        # This Subject is used to transmit mouse moves to labels
        self.mousemove = Subject()

        self.Bind(wx.EVT_MOTION, self.OnMotion)

    def OnMotion(self, event):
        self.mousemove.on_next((event.GetX(), event.GetY()))
Esempio n. 16
0
class DoorListener:
    def __init__(self):
        self.door_message_server = MessageServer(config.door_tag_port)
        self.openDoorStream = Subject()
        self.vibeDoorStream = Subject()

    def on_message(self, data):
        if data == 'door opened':
            self.openDoorStream.on_next(True)
        if data == 'door hit':
            self.vibeDoorStream.on_next(True)

    def listen(self):
        self.door_message_server.listen(self.on_message)
Esempio n. 17
0
            def on_next_left(value):
                subject = Subject()

                with left.lock:
                    _id = left_id[0]
                    left_id[0] += 1
                    left_map[_id] = subject

                try:
                    result = (value, add_ref(subject, rcd))
                except Exception as e:
                    log.error("*** Exception: %s" % e)
                    for left_value in left_map.values():
                        left_value.on_error(e)

                    observer.on_error(e)
                    return

                observer.on_next(result)

                for right_value in right_map.values():
                    subject.on_next(right_value)

                md = SingleAssignmentDisposable()
                group.add(md)

                def expire():
                    if _id in left_map:
                        del left_map[_id]
                        subject.on_completed()

                    group.remove(md)

                try:
                    duration = left_duration_mapper(value)
                except Exception as e:
                    for left_value in left_map.values():
                        left_value.on_error(e)

                    observer.on_error(e)
                    return

                def on_error(error):
                    for left_value in left_map.values():
                        left_value.on_error(error)

                    observer.on_error(error)

                md.disposable = duration.pipe(ops.take(1)).subscribe_(nothing, on_error, expire, scheduler)
Esempio n. 18
0
    def __init__(self, new_players, exiting_players):
        self._new_players = []
        self._players = []
        self._removed_players = []

        new_players.subscribe(self.add_player)
        exiting_players.subscribe(self.remove_player)

        # streams api
        self.new_players_broadcast = Subject()
        self.removed_players_broadcast = Subject()
        self.collisions = Subject()
        self.players = BehaviorSubject([])
        self.players_count = self.players \
            .map(lambda ps: len(ps))
    def open(self):
        scheduler = AsyncIOScheduler()

        print("WebSocket opened")

        # A Subject is both an observable and observer, so we can both subscribe
        # to it and also feed (send) it with new values
        self.subject = Subject()

        # Get all distinct key up events from the input and only fire if long enough and distinct
        searcher = self.subject.pipe(
            ops.map(lambda x: x["term"]),
            ops.filter(lambda text: len(text) > 2),  # Only if the text is longer than 2 characters
            ops.debounce(0.750),                     # Pause for 750ms
            ops.distinct_until_changed(),            # Only if the value has changed
            ops.flat_map_latest(search_wikipedia)
        )

        def send_response(x):
            self.write_message(x.body)

        def on_error(ex):
            print(ex)

        searcher.subscribe(send_response, on_error, scheduler=scheduler)
Esempio n. 20
0
def test_subject_create():
    _x = [None]
    _ex = [None]
    done = False

    def on_next(x):
        _x[0] = x

    def on_error(ex):
        _ex[0] = ex

    def on_completed():
        done = True

    v = AnonymousObserver(on_next, on_error, on_completed)

    o = rx.return_value(42)

    s = Subject.create(v, o)

    def on_next2(x):
        _x[0] = x
    s.subscribe(on_next2)

    assert(42 == _x[0])
    s.on_next(21)

    e = 'ex'
    s.on_error(e)

    assert(e == _ex[0])

    s.on_completed()
    assert(not done)
Esempio n. 21
0
    def __init__(self, name=None, keys=None, desc=None, missing_value=np.nan, data_list=None, use_col_np=False):
        """
        :param name:
        :param keys:
        :param desc:
        :param missing_value:
        :param data_list:
        :param use_col_np: If True, the column based storage of list will used to pass to numpy function
        """
        super(DataSeries, self).__init__()
        self.name = name
        self.keys = self._get_key(keys, None)
        self.desc = desc if desc else name
        self.missing_value = missing_value

        self.data_list = []
        self.time_list = []
        self.data_time_dict = {}
        self.use_col_np = use_col_np

        self.subject = Subject()

        if data_list:
            for data in data_list:
                self.add(data)
  def open(self):
    print("WebSocket opened")
    self.write_message("connection opened")

    def send_response(x):
        self.write_message(json.dumps(x))

    def on_error(ex):
        print(ex)

    self.subject = Subject()

    user_input = self.subject.throttle_last(
        1000  # Given the last value in a given time interval
    ).start_with(
        ''  # Immediately after the subscription sends the default value
    ).filter(
        lambda text: not text or len(text) > 2
    )

    interval_obs = Observable.interval(
        60000  #refresh the value every 60 Seconds for periodic updates
    ).start_with(0)

    self.combine_latest_sbs = user_input.combine_latest(
        interval_obs, lambda input_val, i: input_val
    ).do_action(
        lambda x: send_response('clear')
    ).flat_map(
        self.get_data
    ).subscribe(send_response, on_error)
    def open(self):
        print("WebSocket opened")

        # Subject одновременно и observable, и observer
        self.subject = Subject()

        def send_response(x):
            self.write_message(json.dumps(x))

        def on_error(ex):
            print(ex)

        user_input = self.subject.throttle_last(
            1000  # На заданном временном промежутке получать последнее значение
        ).start_with(
            ''  # Сразу же после подписки отправляет значение по умолчанию
        ).filter(
            lambda text: not text or len(text) > 2
        )

        interval_obs = Observable.interval(
            60000  # Отдает значение раз в 60с (для периодического обновления)
        ).start_with(0)

        # combine_latest собирает 2 потока из запросов пользователя и временных
        # интервалов, срабатывает на любое сообщение из каждого потока
        self.combine_latest_sbs = user_input.combine_latest(
            interval_obs, lambda input_val, i: input_val
        ).do_action(  # Срабатывает на каждый выпущенный элемент
            # Отправляет сообщение для очистки списка на фронтэнд
            lambda x: send_response('clear')
        ).flat_map(
            # В цепочку встраивается observable для получения списка
            self.get_data
        ).subscribe(send_response, on_error)
Esempio n. 24
0
    def open(self):
        print("WebSocket opened")

        # A Subject is both an observable and observer, so we can both subscribe
        # to it and also feed (on_next) it with new values
        self.subject = Subject()

        # Get all distinct key up events from the input and only fire if long enough and distinct
        query = self.subject.select(
            lambda x: x["term"]
        ).filter(
            lambda text: len(text) > 2 # Only if the text is longer than 2 characters
        ).throttle(
            0.750, # Pause for 750ms
            scheduler=scheduler
        ).distinct_until_changed() # Only if the value has changed

        searcher = query.flat_map_latest(search_wikipedia)

        def send_response(x):
            self.write_message(x.body)

        def on_error(ex):
            print(ex)

        searcher.subscribe(send_response, on_error)
Esempio n. 25
0
class WSHandlerSubject(Observable):
    def __init__(self):
        self._subject = Subject()
        super(WSHandlerSubject, self).__init__(self._subject.subscribe)

    async def __call__(self, *args, **kwargs):
        request = args[0]
        web_socket = WebSocketResponse()
        await web_socket.prepare(request)

        ws_subject = WSSubject(web_socket)

        self._subject.on_next(ws_subject)

        await ws_subject.process()

        return web_socket
Esempio n. 26
0
    def __init__(self):
        super(QWidget, self).__init__()
        self.setWindowTitle("Rx for Python rocks")
        self.resize(600, 600)
        self.setMouseTracking(True)

        # This Subject is used to transmit mouse moves to labels
        self.mousemove = Subject()
Esempio n. 27
0
    def __init__(self):
        super().__init__()
        self.resize(600, 600)

        self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
        self.connect('motion-notify-event', self.on_mouse_move)

        self.mousemove = Subject()
Esempio n. 28
0
    def __init__(self):
        super(Frame, self).__init__(None)
        self.SetTitle("Rx for Python rocks")
        self.SetSize((600, 600))

        # This Subject is used to transmit mouse moves to labels
        self.mousemove = Subject()

        self.Bind(wx.EVT_MOTION, self.OnMotion)
Esempio n. 29
0
    def __init__(self, source, pauser=None):
        self.source = source
        self.controller = Subject()

        if pauser and hasattr(pauser, "subscribe"):
            self.pauser = self.controller.merge(pauser)
        else:
            self.pauser = self.controller

        super(PausableBufferedObservable, self).__init__(self._subscribe)
Esempio n. 30
0
    def __init__(self, enable_queue=True, scheduler=None):
        super(ControlledSubject, self).__init__(self._subscribe)

        self.subject = Subject()
        self.enable_queue = enable_queue
        self.queue = [] if enable_queue else None
        self.requested_count = 0
        self.requested_disposable = Disposable.empty()
        self.error = None
        self.has_failed = False
        self.has_completed = False
        self.scheduler = scheduler or current_thread_scheduler
Esempio n. 31
0
            def on_next(x):
                nonlocal s, n, window_id

                new_window = False
                new_id = 0

                s.on_next(x)
                n += 1
                if n == count:
                    new_window = True
                    n = 0
                    window_id += 1
                    new_id = window_id
                    s.on_completed()
                    s = Subject()
                    observer.on_next(add_ref(s, ref_count_disposable))

                if new_window:
                    create_timer(new_id)
Esempio n. 32
0
    def test_stop_default_loop_on_item(self):
        stopped = False
        stop_control = Subject()

        def stop_loop():
            nonlocal stopped
            stopped = True
            stop_control.on_next(True)

        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        loop.call_soon(stop_loop)

        driver = stop.make_driver()
        driver.call(stop.Sink(control=stop_control))

        loop.run_forever()
        loop.close()
        self.assertEqual(True, stopped)
    def __init__(self, id, local_setvelocity_publisher, xoffset, yoffset,
                 leader):
        self.local_setvelocity_publisher = local_setvelocity_publisher
        self.id = id
        self.xoffset = xoffset
        self.yoffset = yoffset
        self.leader = leader
        self.started = False
        self.ros_subscriptions = []

        self.flock_coordinates = {}
        self.leaderposition_subject = Subject()
        self.selfposition_subject = Subject()
        self.leadervelocity_subject = Subject()
        self.selfvelocity_subject = Subject()
        self.flock_repulsion = Subject()

        formation_position_attraction = Observable.combine_latest(
            self.leaderposition_subject, self.selfposition_subject,
            lambda leaderposition, selfposition: self.formation_position(
                leaderposition, selfposition))

        leaderVelocity = self.leadervelocity_subject \
            .map(lambda twist: self.format_velocities(twist))

        leaderVelocityDampening = Observable.combine_latest(
            self.leadervelocity_subject, self.selfvelocity_subject,
            lambda leadertwist, selftwist: self.velocity_dampening(
                leadertwist, selftwist))

        # self.navigate_subscription = Observable.combine_latest([leaderVelocity, formation_position_attraction, self.flock_repulsion], lambda vectors: self.navigate(vectors))

        self.navigate_subscription = Observable.combine_latest([leaderVelocity, leaderVelocityDampening, formation_position_attraction, self.flock_repulsion], lambda *positions: positions) \
            .sample(self.SAMPLE_RATE) \
            .subscribe(lambda vectors: self.navigate(vectors))

        # self.navigate_subscription = self.flock_repulsion \
        #     .subscribe(lambda vectors: self.navigate([vectors]))

        self.flockSubscription = Observable.empty().subscribe()
Esempio n. 34
0
def test_event_order_is_correct_for_multiple_publishes():
    # type: () -> None
    stream = Subject()
    send_important_email, subscription = create_subscription(stream)

    payload = []

    subscription.subscribe(payload.append)
    send_important_email(
        Email(
            from_="*****@*****.**",
            subject="Message",
            message="Tests are good",
            unread=True,
        )
    )
    send_important_email(
        Email(
            from_="*****@*****.**",
            subject="Message 2",
            message="Tests are good 2",
            unread=True,
        )
    )

    expected_payload1 = {
        "importantEmail": {
            "email": {"from": "*****@*****.**", "subject": "Message"},
            "inbox": {"unread": 1, "total": 2},
        }
    }

    expected_payload2 = {
        "importantEmail": {
            "email": {"from": "*****@*****.**", "subject": "Message 2"},
            "inbox": {"unread": 2, "total": 3},
        }
    }

    assert len(payload) == 2
    assert payload[0].data == expected_payload1
    assert payload[1].data == expected_payload2
Esempio n. 35
0
    def subscribe(observer):
        m = SerialDisposable()
        d = CompositeDisposable(m)
        r = RefCountDisposable(d)
        window = [Subject()]

        observer.on_next(add_ref(window[0], r))

        def on_next(x):
            window[0].on_next(x)

        def on_error(ex):
            window[0].on_error(ex)
            observer.on_error(ex)

        def on_completed():
            window[0].on_completed()
            observer.on_completed()

        d.add(source.subscribe(on_next, on_error, on_completed))

        def create_window_close():
            try:
                window_close = window_closing_selector()
            except Exception as exception:
                log.error("*** Exception: %s" % exception)
                observer.on_error(exception)
                return

            def on_completed():
                window[0].on_completed()
                window[0] = Subject()
                observer.on_next(add_ref(window[0], r))
                create_window_close()

            m1 = SingleAssignmentDisposable()
            m.disposable = m1
            m1.disposable = window_close.take(1).subscribe(
                noop, on_error, on_completed)

        create_window_close()
        return r
Esempio n. 36
0
    def test_paused_skips(self):
        subscription = [None]

        scheduler = TestScheduler()

        controller = Subject()

        results = scheduler.create_observer()

        xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2),
                                             on_next(230, 3), on_next(301, 4),
                                             on_next(350, 5), on_next(399, 6),
                                             on_completed(500))

        def action0(scheduler, state):
            subscription[0] = xs.pausable(controller).subscribe(results)
            controller.on_next(True)

        scheduler.schedule_absolute(200, action0)

        def action1(scheduler, state):
            controller.on_next(False)

        scheduler.schedule_absolute(300, action1)

        def action2(scheduler, state):
            controller.on_next(True)

        scheduler.schedule_absolute(400, action2)

        def action3(scheduler, state):
            subscription[0].dispose()

        scheduler.schedule_absolute(1000, action3)

        scheduler.start()

        assert results.messages == [
            on_next(210, 2),
            on_next(230, 3),
            on_completed(500)
        ]
Esempio n. 37
0
class Client:
    def __init__(self, host = 'localhost', port = 8888):
        self.url = 'ws://{}/{}/exchange'.format(host, port)
        self.conn = None
        self.opened = Subject()
        self.messages = Subject()

    def write_message(self, message):
        self.conn.w

    def connect(self):
        def on_message_callback(message):
            self.messages.on_next(message)

        def on_connect(connection):
            self.conn = connection
            self.opened.on_next(connection)
            self.opened.on_completed()
            self.opened.dispose()

        future = websocket_connect(self.url, on_message_callback=on_message_callback)
        Observable.from_future(future).subscribe(on_connect)
Esempio n. 38
0
    def subscribe(observer, scheduler=None):
        m = SerialDisposable()
        d = CompositeDisposable(m)
        r = RefCountDisposable(d)
        window = [Subject()]

        observer.on_next(add_ref(window[0], r))

        def on_next(value):
            window[0].on_next(value)

        def on_error(error):
            window[0].on_error(error)
            observer.on_error(error)

        def on_completed():
            window[0].on_completed()
            observer.on_completed()

        d.add(source.subscribe_(on_next, on_error, on_completed, scheduler))

        def create_window_on_completed():
            try:
                window_close = window_closing_mapper()
            except Exception as exception:
                observer.on_error(exception)
                return

            def on_completed():
                window[0].on_completed()
                window[0] = Subject()
                observer.on_next(add_ref(window[0], r))
                create_window_on_completed()

            m1 = SingleAssignmentDisposable()
            m.disposable = m1
            m1.disposable = window_close.pipe(ops.take(1)).subscribe_(
                noop, on_error, on_completed, scheduler)

        create_window_on_completed()
        return r
Esempio n. 39
0
    def test_multicast_hot_1(self):
        scheduler = TestScheduler()

        s = Subject()

        xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1),
                                             on_next(150, 2), on_next(210, 3),
                                             on_next(240, 4), on_next(270, 5),
                                             on_next(330, 6), on_next(340, 7),
                                             on_completed(390))

        o = scheduler.create_observer()
        d1 = [None]
        d2 = [None]
        c = [None]

        def action(scheduler, state):
            c[0] = xs.multicast(s)

        scheduler.schedule_absolute(50, action)

        def action0(scheduler, state):
            d1[0] = c[0].subscribe(o)

        scheduler.schedule_absolute(100, action0)

        def action1(scheduler, state):
            d2[0] = c[0].connect()

        scheduler.schedule_absolute(200, action1)

        def action2(scheduler, state):
            d1[0].dispose()

        scheduler.schedule_absolute(300, action2)

        scheduler.start()

        o.messages.assert_equal(on_next(210, 3), on_next(240, 4),
                                on_next(270, 5))
        xs.subscriptions.assert_equal(subscribe(200, 390))
Esempio n. 40
0
class AsyncConnection(asyncio.Protocol, Connection):
    def __init__(self, on_connect):
        super().__init__()
        self.on_connect = on_connect

    def connection_made(self, transport: asyncio.Transport):
        peername = transport.get_extra_info('peername')
        logger.info('Connection from %s', peername)
        self.transport = transport
        self.data_in = Subject()
        self.data_out = AnonymousObserver(self.on_data_out_next,
                                          self.on_data_out_error,
                                          self.on_data_out_completed)
        self.on_connect(self)

    def eof_received(self):
        logger.debug('data eof received')
        self.data_in.on_completed()

    def resume_writing(self):
        logger.debug('data resume')

    def pause_writing(self):
        logger.debug('data pause')

    def connection_lost(self, exc):
        logger.debug('data connection lost')
        self.data_in.on_error(exc)

    def data_received(self, data):
        logger.debug('data received: %s', data)
        self.data_in.on_next(data)

    def on_data_out_next(self, data):
        logger.debug('sending: %s', data)
        self.transport.write(data)

    def on_data_out_error(self, exception):
        logger.exception('data_out error: %r', exception)
        self.close()

    def on_data_out_completed(self):
        logger.info('data_out completed')
        self.close()

    def close(self):
        self.transport.close()
Esempio n. 41
0
def adapter(source):
    sink_request = Subject()

    def walk(top, recursive=False):
        def on_subscribe(observer):
            response = (source.filter(lambda i: i.id is response_observable).
                        take(1).map(lambda i: i.content))

            dispose = response.subscribe(observer)
            sink_request.on_next(
                Walk(
                    id=response_observable,
                    top=top,
                    recursive=recursive,
                ))

            return dispose

        response_observable = Observable.create(on_subscribe)
        return response_observable

    return Adapter(sink=sink_request, api=Api(walk=walk, ))
Esempio n. 42
0
    def test_paused_with_state_change_in_subscriber(self):
        scheduler = TestScheduler()

        results = scheduler.create_observer()

        xs = scheduler.create_hot_observable(on_next(150, 1), on_next(210, 2),
                                             on_next(250, 3), on_next(270, 4),
                                             on_next(330, 5),
                                             on_completed(500))

        controller = Subject()

        pausable_buffered = xs.pausable_buffered(controller)

        def action1(scheduler, state):
            def on_next(value):
                results.on_next(value)
                controller.on_next(False)

                def action2(scheduler, state):
                    controller.on_next(True)

                scheduler.schedule_relative(100, action2)

            subscription = pausable_buffered.subscribe_(
                on_next, results.on_error, results.on_completed)
            controller.on_next(True)

        scheduler.schedule_absolute(200, action1)

        scheduler.start()

        assert results.messages == [
            on_next(210, 2),
            on_next(310, 3),
            on_next(310, 4),
            on_next(410, 5),
            on_completed(500)
        ]
Esempio n. 43
0
    def test_multicast_hot_2(self):
        c = [None]
        d1 = [None]
        d2 = [None]
        scheduler = TestScheduler()
        xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1),
                                             on_next(150, 2), on_next(210, 3),
                                             on_next(240, 4), on_next(270, 5),
                                             on_next(330, 6), on_next(340, 7),
                                             on_completed(390))
        s = Subject()
        o = scheduler.create_observer()

        def action0(scheduler, state):
            c[0] = xs.multicast(s)

        scheduler.schedule_absolute(50, action0)

        def action1(scheduler, state):
            d2[0] = c[0].connect(scheduler)

        scheduler.schedule_absolute(100, action1)

        def action2(scheduler, state):
            d1[0] = c[0].subscribe(o, scheduler)

        scheduler.schedule_absolute(200, action2)

        def action3(scheduler, state):
            return d1[0].dispose()

        scheduler.schedule_absolute(300, action3)

        scheduler.start()
        assert o.messages == [
            on_next(210, 3), on_next(240, 4),
            on_next(270, 5)
        ]
        assert xs.subscriptions == [subscribe(100, 390)]
Esempio n. 44
0
    def __init__(self,
                 tupleSelector: TupleSelector,
                 cacheEnabled: bool = True) -> None:
        if _CachedSubscribedData.__memoryLoggingEnabled:
            _CachedSubscribedData.__memoryLoggingRefs.append(weakref.ref(self))

        self.tupleSelector: TupleSelector = tupleSelector
        self.vortexUuids: Set[str] = set()
        self.tearDownDate: Optional[datetime] = None
        self.encodedPayload: bytes = None

        #: Is the cache enabled
        # HINT: Once it's turned off for a tupleSelector, it remains off.
        # Disabling it can also be done from VortexJS
        self.cacheEnabled = cacheEnabled

        #: Last Server Payload Date
        # If the server has responded with a payload, this is the date in the payload
        # @type {Date | null}
        self.lastServerPayloadDate: Optional[datetime] = None

        self.subject = Subject()
Esempio n. 45
0
def main():
    root = Tk()
    root.title("Rx for Python rocks")
    scheduler = TkinterScheduler(root)

    mousemove = Subject()

    frame = Frame(root, width=600, height=600)

    frame.bind("<Motion>", mousemove.on_next)

    text = 'TIME FLIES LIKE AN ARROW'

    def on_next(info):
        label, ev, i = info
        label.place(x=ev.x + i*12 + 15, y=ev.y)

    def handle_label(label, i):
        label.config(dict(borderwidth=0, padx=0, pady=0))

        mapper = ops.map(lambda ev: (label, ev, i))
        delayer = ops.delay(i*0.1)

        return mousemove.pipe(
            delayer,
            mapper
        )

    labeler = ops.flat_map_indexed(handle_label)
    mapper = ops.map(lambda c: Label(frame, text=c))

    rx.from_(text).pipe(
        mapper,
        labeler
    ).subscribe(on_next, on_error=print, scheduler=scheduler)

    frame.pack()
    root.mainloop()
Esempio n. 46
0
def test_subject_create():
    _x = None
    _ex = None
    done = False

    def on_next(x):
        nonlocal _x
        _x = x

    def on_error(ex):
        nonlocal _ex
        _ex = ex

    def on_completed():
        done = True

    v = Observer(on_next, on_error, on_completed)

    o = Observable.return_value(42)

    s = Subject.create(v, o)

    def on_next2(x):
        nonlocal _x
        _x = x

    s.subscribe(on_next2)

    assert (42 == _x)
    s.on_next(21)

    e = 'ex'
    s.on_error(e)

    assert (e == _ex)

    s.on_completed()
    assert (not done)
Esempio n. 47
0
def make_sink_proxies(drivers):
    ''' Build a list of sink proxies. sink proxies are a two-level ordered
    dictionary. The first level contains the lst of drivers, and the second
    level contains the list of sink proxies for each driver:

    drv1-->sink1
      | |->sink2
      |
    drv2-->sink1
        |->sink2
    '''
    sink_proxies = OrderedDict()
    if drivers is not None:
        for driver_name in drivers._fields:
            driver = getattr(drivers, driver_name)
            driver_sink = getattr(driver, 'input')
            if driver_sink is not None:
                driver_sink_proxies = OrderedDict()
                for name in driver_sink._fields:
                    driver_sink_proxies[name] = Subject()

                sink_proxies[driver_name] = driver.input(**driver_sink_proxies)
    return sink_proxies
Esempio n. 48
0
    def __init__(self, chr_contr, executor, gen0=None, opts=default_options):
        self.gen0 = gen0
        self.chr_contr = chr_contr
        self.pauser = Pauser()
        self.executor = executor
        self.executor.kpp_fun = self.pauser.kpp
        self.sub_chr_best = ReplaySubject()
        self.sub_gen_solved = Subject()
        self.sub_gen_unsolved = Subject()
        self.subj_done = Subject()

        self.su_genetic = StepUpGenetic(chr_contr)

        self.opts = dict(default_options)
        self.init_opts(opts)
        self.stop_flag = True
        self.gen_flag = True
        self.init_logic()
Esempio n. 49
0
    def test_add_route(self):
        routes = [
            httpd.AddRoute(methods=['GET'], path='/foo', id='foo'),
            httpd.AddRoute(methods=['POST'], path='/bar', id='bar'),
            httpd.AddRoute(methods=['PUT'], path='/biz', id='biz'),
        ]
        actual_routes = []
        loop = asyncio.new_event_loop()
        loop.set_debug(True)
        asyncio.set_event_loop(loop)

        sink = httpd.Sink(control=Subject())

        def setup(sink):
            sink.control.on_next(httpd.Initialize()),
            sink.control.on_next(httpd.StartServer(host='localhost', port=9999)),
            for route in routes:
                sink.control.on_next(route)

        def on_route_item(i):
            if type(i) is httpd.RouteAdded:
                actual_routes.append(i)
                # stop mainloop when last route is created
                if i.id == routes[-1].id:
                    asyncio.get_event_loop().stop()

        loop.call_soon(setup, sink)
        source = httpd.make_driver(loop).call(sink)
        source.route.subscribe(on_route_item)
        loop.run_forever()
        loop.close()

        self.assertEqual(len(routes), len(actual_routes))
        for index,route in enumerate(actual_routes):
            self.assertEqual(routes[index].path, route.path)
            self.assertEqual(routes[index].id, route.id)
            self.assertIsInstance(route.request, Observable)
Esempio n. 50
0
        def __init__(self):
            scheduler = IOLoopScheduler(IOLoop.current())
            self._app = Application([
                (r'/exchange', ExchangeHandler),
            ])

            self._servers = [
                ['localhost', '8888'],
                ['localhost', '7777'],
            ]
            self._current_server = 0

            self.messages = Subject()

            def passthrough_to_matching_server(msg):
                if self.matching_server_connection is None:
                    print('server is DOWN')
                    return
                self.matching_server_connection.write_message(msg)

            self.only_messages = self.messages \
                .filter(lambda msg: msg[0] == 'message') \
                .map(lambda msg: msg[1]) \
                .subscribe(passthrough_to_matching_server)
Esempio n. 51
0
 def subject_selector():
     return Subject()
Esempio n. 52
0
 def subject_factory(scheduler):
     return Subject()
Esempio n. 53
0
def get_config():
    config_file = open(os.path.join(DIRNAME, '..', 'config.json'), 'r')
    config = json.load(config_file)
    config_file.close()
    return config


CONFIG = get_config()
VARS = {
    'endpoint_id': None,
    'message_queue': ReplaySubject(),
    'message_id': 0,
    'sock': None,
    'message_buffer': []
}
EVENT_SOURCE = Subject()


def get_message_id():
    """get unique message id"""
    num = VARS['message_id']
    VARS['message_id'] = VARS['message_id'] + 1
    return '{!s}:{!s}'.format(VARS['endpoint_id'], num)


def _on_message(msg):
    if msg is None:
        #disconnected
        on_disconnect()
        reconnect()
    else:
Esempio n. 54
0
class HttpParser(Observer):
    def __init__(self, conn):
        super(HttpParser, self).__init__()
        self.conn = conn
        self.buf = StringIO()
        self.requests_in = Subject()
        self.responses_out = HttpWriter(conn)
        self.keep_alive_timeout_dispose = Disposable.empty()
        self.read_timeout_dispose = Disposable.empty()
        self.keep_alive_timer_on()

    def schedule_timeout(self, seconds):
        def action(scheduler, state=None):
            print 'timeout', seconds
            self.requests_in.on_error(HttpResponse(408, 'Request Timeout'))

        return scheduler.schedule_relative(timedelta(seconds=seconds), action)

    def clear_timeout(self, disposable):
        try:
            disposable.dispose()
        except:  # Twisted sometimes complains when we try to cancel timeout after it has already fired
            pass

    def keep_alive_timer_on(self):
        self.keep_alive_timer_off()
        self.keep_alive_timeout_dispose = self.schedule_timeout(
            KEEP_ALIVE_TIMEOUT)

    def keep_alive_timer_off(self):
        self.clear_timeout(self.keep_alive_timeout_dispose)

    def read_timer_on(self):
        self.read_timer_off()
        self.read_timeout_dispose = self.schedule_timeout(READ_TIMEOUT)

    def read_timer_off(self):
        self.clear_timeout(self.read_timeout_dispose)

    def parse_request(self, buf):
        lines = buf.split('\r\n')
        first_line = lines[0].split()
        if len(first_line) == 3:
            self.requests_in.on_next(
                HttpRequest(self.conn, first_line[0], first_line[1]))
        else:
            self.requests_in.on_error(HttpResponse(400, 'Bad Request'))

    def on_next(self, data):
        self.keep_alive_timer_off()
        self.read_timer_on()
        self.buf.write(data)  # append new data
        buf = self.buf.getvalue()
        eor = buf.find('\r\n\r\n')  # check we've got full request
        if eor >= 0:
            self.buf = StringIO()
            self.buf.write(buf[eor + 4:])  # leave remainder in buf
            self.parse_request(buf[:eor])
            self.read_timer_off()
            self.keep_alive_timer_on()

    def on_error(self, e):
        print 'parser got error', e
        self.keep_alive_timer_off()
        self.read_timer_off()
        self.requests_in.on_error(HttpResponse(500, 'Internal Server Error'))

    def on_completed(self):
        print 'parser completed'
        self.keep_alive_timer_off()
        self.read_timer_off()
        self.requests_in.on_completed()
Esempio n. 55
0
 def connectionMade(self):
     self.data_in = Subject()
     self.listener.on_next(self)
Esempio n. 56
0
class WorkspaceProcessContext:
    """
    This class is process-scoped object that is initialized using the repository handles from a
    Workspace. The responsibility of this class is to:

    1. Maintain an update-to-date dictionary of repository locations
    1. Create `WorkspaceRequestContexts` whever a request is made
    2. Run watch thread processes that monitor repository locations

    In most cases, you will want to create a `WorkspaceRequestContext` to make use of this class.
    """

    def __init__(self, instance, workspace, version=None):
        # lazy import for perf
        from rx.subjects import Subject

        self._instance = check.inst_param(instance, "instance", DagsterInstance)
        self._workspace = workspace

        self._location_state_events = Subject()
        self._location_state_subscriber = LocationStateSubscriber(
            self._location_state_events_handler
        )

        self.version = version

        self._initialize_repository_locations()

    def _initialize_repository_locations(self):
        self._repository_locations = {}
        for location in self._workspace.repository_locations:
            check.invariant(
                self._repository_locations.get(location.name) is None,
                'Cannot have multiple locations with the same name, got multiple "{name}"'.format(
                    name=location.name,
                ),
            )

            location.add_state_subscriber(self._location_state_subscriber)
            self._repository_locations[location.name] = location

    def create_request_context(self):
        return WorkspaceRequestContext(
            instance=self.instance,
            workspace_snapshot=self._workspace.create_snapshot(),
            repository_locations_dict=self._repository_locations.copy(),
            process_context=self,
            version=self.version,
        )

    @property
    def instance(self):
        return self._instance

    @property
    def repository_locations(self):
        return list(self._repository_locations.values())

    @property
    def location_state_events(self):
        return self._location_state_events

    def _location_state_events_handler(self, event):
        # If the server was updated or we were not able to reconnect, we immediately reload the
        # location handle
        if event.event_type in (
            LocationStateChangeEventType.LOCATION_UPDATED,
            LocationStateChangeEventType.LOCATION_ERROR,
        ):
            # In case of an updated location, reload the handle to get updated repository data and
            # re-attach a subscriber
            # In case of a location error, just reload the handle in order to update the workspace
            # with the correct error messages
            self.reload_repository_location(event.location_name)

        self._location_state_events.on_next(event)

    def reload_repository_location(self, name):
        self._workspace.reload_repository_location(name)

        if self._workspace.has_repository_location(name):
            new_location = self._workspace.get_repository_location(name)
            new_location.add_state_subscriber(self._location_state_subscriber)
            check.invariant(new_location.name == name)
            self._repository_locations[name] = new_location
        elif name in self._repository_locations:
            del self._repository_locations[name]

        return self

    def reload_workspace(self):
        self._workspace.reload_workspace()
        self._initialize_repository_locations()
Esempio n. 57
0
    def __init__(self,
                 width,
                 height,
                 path,
                 plist,
                 target,
                 is_workspace,
                 is_release,
                 is_http,
                 fir='',
                 store_name='',
                 store_pwd=''):
        """
        此窗口 固定宽高 ,不可变动
        :param width: 窗口宽度
        :param height: 窗口高度
        公开属性:
        window, 主窗体
        source, Rx 信号体 通过 source.subscribe(... 获得回调信号
        """
        TkBase.__init__(self, width, height)

        self.project_path = tk.StringVar()
        self.plist_path = tk.StringVar()
        self.target = tk.StringVar()
        self.project_path.set(os.path.abspath('..'))  # 默认父级目录
        self.plist_path.set(os.path.abspath('.') +
                            '/ipaAppStore.plist')  # 默认当前目录
        self.record_info = tk.StringVar()
        self.record_info.set('AutomationIpaInfo')

        self.is_workspace = tk.BooleanVar()
        self.is_workspace.set(True)
        self.is_release = tk.BooleanVar()
        self.is_release.set(True)
        self.is_git = tk.BooleanVar()
        self.is_git.set(True)

        self.is_http = tk.BooleanVar()
        self.is_http.set(False)

        self.fir_token = tk.StringVar()
        self.fir_token.set('')
        self.is_fir = tk.BooleanVar()
        self.is_fir.set(True)

        self.store_name = tk.StringVar()
        self.store_name.set('')
        self.store_pwd = tk.StringVar()
        self.store_pwd.set('')
        self.is_store = tk.BooleanVar()
        self.is_store.set(True)

        self.__make_var()
        self.__make_widgets()
        self.source = Subject()

        self.project_path.set(path)

        self.plist_path.set(plist)

        self.target.set(target)

        self.is_workspace.set(is_workspace)

        self.is_release.set(is_release)
        self.is_fir.set(not is_release)
        self.is_store.set(is_release)

        self.is_http.set(is_http)

        self.fir_token.set(fir)
        self.store_name.set(store_name)
        self.store_pwd.set(store_pwd)
Esempio n. 58
0
class TkSelect(TkBase):
    def __init__(self,
                 width,
                 height,
                 path,
                 plist,
                 target,
                 is_workspace,
                 is_release,
                 is_http,
                 fir='',
                 store_name='',
                 store_pwd=''):
        """
        此窗口 固定宽高 ,不可变动
        :param width: 窗口宽度
        :param height: 窗口高度
        公开属性:
        window, 主窗体
        source, Rx 信号体 通过 source.subscribe(... 获得回调信号
        """
        TkBase.__init__(self, width, height)

        self.project_path = tk.StringVar()
        self.plist_path = tk.StringVar()
        self.target = tk.StringVar()
        self.project_path.set(os.path.abspath('..'))  # 默认父级目录
        self.plist_path.set(os.path.abspath('.') +
                            '/ipaAppStore.plist')  # 默认当前目录
        self.record_info = tk.StringVar()
        self.record_info.set('AutomationIpaInfo')

        self.is_workspace = tk.BooleanVar()
        self.is_workspace.set(True)
        self.is_release = tk.BooleanVar()
        self.is_release.set(True)
        self.is_git = tk.BooleanVar()
        self.is_git.set(True)

        self.is_http = tk.BooleanVar()
        self.is_http.set(False)

        self.fir_token = tk.StringVar()
        self.fir_token.set('')
        self.is_fir = tk.BooleanVar()
        self.is_fir.set(True)

        self.store_name = tk.StringVar()
        self.store_name.set('')
        self.store_pwd = tk.StringVar()
        self.store_pwd.set('')
        self.is_store = tk.BooleanVar()
        self.is_store.set(True)

        self.__make_var()
        self.__make_widgets()
        self.source = Subject()

        self.project_path.set(path)

        self.plist_path.set(plist)

        self.target.set(target)

        self.is_workspace.set(is_workspace)

        self.is_release.set(is_release)
        self.is_fir.set(not is_release)
        self.is_store.set(is_release)

        self.is_http.set(is_http)

        self.fir_token.set(fir)
        self.store_name.set(store_name)
        self.store_pwd.set(store_pwd)

    def __make_var(self):
        path = os.path.abspath('..')  # 获取当前父级目录
        self.project_path.set(path)  # 默认父级目录
        # 获取父级目录下所有文件
        for name in os.listdir(path):
            if name.endswith('.xcodeproj'):
                self.target.set(name.split('.')[0])
                self.is_workspace.set(False)

            if name.endswith('.xcworkspace'):
                self.target.set(name.split('.')[0])
                self.is_workspace.set(True)

    def run(self):
        self.window.mainloop()

    def quit(self):
        self.window.quit()
        self.window.destroy()

    def __make_widgets(self):
        # 底部容器
        frame0 = tk.Frame(self.window)
        frame0.grid(row=0, column=0)

        frame1 = tk.Frame(self.window)
        frame1.grid(row=1, column=0)

        frame2 = tk.Frame(self.window)
        frame2.grid(row=2, column=0)

        # frame0 容器
        self.__make_title_empty(frame0, 0, 0)
        f1 = tk.Frame(frame0)
        f1.grid(row=1, column=0)

        f2 = tk.Frame(frame0)
        f2.grid(row=1, column=1)

        # frame1 容器
        self.__make_title_empty(frame1, 0, 0)
        self.__make_select_confirm(frame1, 1, 0)

        # frame2 容器
        self.__make_title_info(frame2, 0, 0)

        # f1 容器
        self.__make_title_empty(f1, 0, 0)
        self.__make_title(f1, 0, 1, '项目目录:(选择.xcworkspace or .xcodeproj文件)')
        self.__make_title_empty(f1, 1, 0)
        self.__make_select_text(f1, 1, 1, 1, self.project_path)

        self.__make_title_empty(f1, 2, 0)
        self.__make_title(f1, 2, 1, '配置.plist 路径:(对应是否Release,不可单独修改)')
        self.__make_title_empty(f1, 3, 0)
        self.__make_select_text(f1, 3, 1, 2, self.plist_path)

        self.__make_title_empty(f1, 4, 0)
        self.__make_title(f1, 4, 1, '项目 Target:')
        self.__make_title_empty(f1, 5, 0)
        self.__make_select_text(f1, 5, 1, 2, self.target, False)
        """
        self.__make_title_empty(f1, 6, 0)
        self.__make_title(f1, 6, 1, '配置存储文件名')
        self.__make_title_empty(f1, 7, 0)
        self.__make_select_text(f1, 7, 1, 2, self.record_info, False)
        """

        self.__make_title_empty(f1, 8, 0)
        self.__make_title(f1, 8, 1, 'Fir Token:')
        self.__make_title_empty(f1, 9, 0)
        self.__make_select_text(f1, 9, 1, 2, self.fir_token, False)

        self.__make_title_empty(f1, 10, 0)
        self.__make_title(f1, 10, 1, 'App Store 账号:')
        self.__make_title_empty(f1, 11, 0)
        self.__make_select_text(f1, 11, 1, 2, self.store_name, False)

        self.__make_title_empty(f1, 12, 0)
        self.__make_title(f1, 12, 1, 'App Store 密码:')
        self.__make_title_empty(f1, 13, 0)
        self.__make_select_text(f1, 13, 1, 2, self.store_pwd, False)

        # f2 容器
        self.__make_title(f2, 0, 0, '是否.workspace:', 15, 'e')
        self.__make_radio_button(f2, 0, 1, '是', True, self.is_workspace)
        self.__make_radio_button(f2, 0, 2, '否', False, self.is_workspace)
        self.__make_title_empty(f2, 1, 0)

        self.__make_title(f2, 2, 0, '是否 Release:', 15, 'e')
        self.__make_radio_button(f2, 2, 1, '是', True, self.is_release)
        self.__make_radio_button(f2, 2, 2, '否', False, self.is_release)
        self.__make_title_empty(f2, 3, 0)

        self.__make_title(f2, 4, 0, 'Git or SVN:', 15, 'e')
        self.__make_radio_button(f2, 4, 1, 'Git', True, self.is_git)
        self.__make_radio_button(f2, 4, 2, 'SVN', False, self.is_git)
        self.__make_title_empty(f2, 5, 0)

        self.__make_title(f2, 6, 0, '开启http服务:', 15, 'e')
        self.__make_radio_button(f2, 6, 1, '开', True, self.is_http)
        self.__make_radio_button(f2, 6, 2, '关', False, self.is_http)
        self.__make_title_empty(f2, 7, 0)

        self.__make_title(f2, 8, 0, '上传到fir.im:', 15, 'e')
        self.__make_radio_button(f2, 8, 1, '是', True, self.is_fir)
        self.__make_radio_button(f2, 8, 2, '否', False, self.is_fir)
        self.__make_title_empty(f2, 9, 0)

        self.__make_title(f2, 10, 0, '上传到App Store:', 15, 'e')
        self.__make_radio_button(f2, 10, 1, '是', True, self.is_store)
        self.__make_radio_button(f2, 10, 2, '否', False, self.is_store)
        self.__make_title_empty(f2, 11, 0)

    def __make_title_empty(self, frame, row, column):
        tk.Label(frame, text='', width=1, anchor='w').grid(row=row,
                                                           column=column)

    def __make_title_info(self, frame, row, column):
        tk.Label(frame,
                 text=info,
                 font=('Arial', 10),
                 fg='gray',
                 width=90,
                 justify='left',
                 anchor='w').grid(row=row, column=column)

    def __make_title(self,
                     frame,
                     row,
                     column,
                     title='  ',
                     width=35,
                     anchor='w'):
        tk.Label(frame, text=title, width=width,
                 anchor=anchor).grid(row=row, column=column)

    def __make_select_text(self, frame, row, column, tag, text, sele=True):
        entry = tk.Entry(frame, width=35, textvariable=text)
        entry.grid(row=row, column=column)
        if sele:
            button = tk.Button(frame, text='选择')
            button.grid(row=row, column=column + 1)
            button['command'] = (lambda: self.__click_select(entry, tag))

    def __make_radio_button(self, frame, row, column, text, val, var):
        tk.Radiobutton(frame, text=text, width=5, variable=var,
                       value=val).grid(row=row, column=column)

    def __print_selection(self, tag):
        pass

    def __click_select(self, entry, tag):

        if tag == 1:
            path = filedialog.askopenfilename()
            if len(path) > 0:
                t = '/'
                list = path.split('/')
                pro = list.pop()
                path = t.join(list)
                self.is_workspace.set('.xcworkspace' in pro)
                tag = pro.split('.')[0]
                self.project_path.set(path)
                self.target.set(tag)
        else:
            path = filedialog.askopenfilename()
            if len(path) > 0:
                t = '/'
                self.plist_path.set(path)
                list = path.split('/')
                pro = list.pop()
                self.is_release.set('AppStore' in pro)

    def __select_excel_input(self, entry_box):
        path = filedialog.askopenfilename()
        entry_box.delete(0, len(entry_box.get()))
        entry_box.insert(0, path)
        self.project_path = path

    # 如果 函数内部没有使用到 self. 会提示 Method 'select_excel_input' may be 'static' less... (⌘F1)
    # 会建议你 要么 加上@staticmethod ,要么放到class外面去
    def __select_excel_output(self, entry_box):
        path = askdirectory()
        entry_box.delete(0, len(entry_box.get()))
        entry_box.insert(0, path)
        return path

    def __make_select_confirm(self, frame, row, column):
        button = tk.Button(frame, width=15, text='开启自动打包')
        button.grid(row=row, column=column)
        button['command'] = (lambda: self.__click_browser())

    def __click_browser(self):
        if len(self.project_path.get()) > 0 and len(
                self.plist_path.get()) > 0 and len(self.target.get()) > 0:
            self.quit()

            # 去除了 plist 文件输入框 这里根据 选择重新配置
            """
            if self.is_release.get():
                self.plist_path.set(os.path.abspath('.') + '/ipaAppStore.plist')
            else:
                self.plist_path.set(os.path.abspath('.') + '/ipaAdHoc.plist')
                
            """

            self.source.on_next(
                (self.project_path.get(), self.plist_path.get(),
                 self.target.get(), self.is_workspace.get(),
                 self.is_release.get(), self.is_http.get(),
                 self.fir_token.get(), self.store_name.get(),
                 self.store_pwd.get()))
 def create_window():
     s = Subject()
     q.append(s)
     observer.on_next(add_ref(s, refCountDisposable))
Esempio n. 60
0
class ControlledSubject(ObservableBase, Observer):
    def __init__(self, enable_queue=True, scheduler=None):
        super(ControlledSubject, self).__init__()

        self.subject = Subject()
        self.enable_queue = enable_queue
        self.queue = [] if enable_queue else None
        self.requested_count = 0
        self.requested_disposable = Disposable.empty()
        self.error = None
        self.has_failed = False
        self.has_completed = False
        self.scheduler = scheduler or current_thread_scheduler

    def _subscribe_core(self, observer):
        return self.subject.subscribe(observer)

    def on_completed(self):
        self.has_completed = True

        if not self.enable_queue or len(self.queue) == 0:
            self.subject.on_completed()
            self.dispose_current_request()
        else:
            self.queue.append(OnCompleted())

    def on_error(self, error):
        self.has_failed = True
        self.error = error

        if not self.enable_queue or len(self.queue) == 0:
            self.subject.on_error(error)
            self.dispose_current_request()
        else:
            self.queue.append(OnError(error))

    def on_next(self, value):
        if self.requested_count <= 0:
            self.enable_queue and self.queue.append(OnNext(value))
        else:
            self.requested_count -= 1
            if self.requested_count == 0:
                self.dispose_current_request()
            self.subject.on_next(value)

    def _process_request(self, number_of_items):
        if self.enable_queue:
            while len(self.queue) > 0 and (number_of_items > 0
                                           or self.queue[0].kind != 'N'):
                first = self.queue.pop(0)
                first.accept(self.subject)
                if first.kind == 'N':
                    number_of_items -= 1
                else:
                    self.dispose_current_request()
                    self.queue = []

        return number_of_items

    def request(self, number):
        self.dispose_current_request()

        def action(scheduler, i):
            remaining = self._process_request(i)
            stopped = self.has_completed and self.has_failed
            if not stopped and remaining > 0:
                self.requested_count = remaining

            def dispose():
                self.requested_count = 0

            return AnonymousDisposable(dispose)
            # Scheduled item is still in progress. Return a new
            # disposable to allow the request to be interrupted
            # via dispose.

        self.requested_disposable = self.scheduler.schedule(action,
                                                            state=number)
        return self.requested_disposable

    def dispose_current_request(self):
        if self.requested_disposable:
            self.requested_disposable.dispose()
            self.requested_disposable = None