Пример #1
0
    def _process_request(self, number_of_items):
        if self.enable_queue:
            #console.log('queue length', self.queue.length)

            while len(self.queue) >= number_of_items and number_of_items > 0:
                # console.log('number of items', number_of_items)
                self.subject.on_next(self.queue.shift())
                number_of_items -= 1

            if len(self.queue):
                return {
                    "number_of_items": number_of_items,
                    "return_value": True
                }
            else:
                return {
                    "number_of_items": number_of_items,
                    "return_value": False
                }

        if self.has_failed:
            self.subject.on_error(self.error)
            self.controlled_disposable.dispose()
            self.controlled_disposable = Disposable.empty()
        elif self.has_completed:
            self.subject.on_completed()
            self.controlled_disposable.dispose()
            self.controlled_disposable = Disposable.empty()

        return {"number_of_items": number_of_items, "return_value": False}
Пример #2
0
 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()
Пример #3
0
def test_groupdisposable_contains():
    d1 = Disposable.empty()
    d2 = Disposable.empty()

    g = CompositeDisposable(d1, d2)
    
    assert g.length == 2
    assert g.contains(d1)
    assert g.contains(d2)
Пример #4
0
def test_groupdisposable_contains():
    d1 = Disposable.empty()
    d2 = Disposable.empty()

    g = CompositeDisposable(d1, d2)

    assert g.length == 2
    assert g.contains(d1)
    assert g.contains(d2)
Пример #5
0
    def __init__(self, enable_queue=True):
        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.controlled_disposable = Disposable.empty()
Пример #6
0
    def __init__(self, enable_queue=True):
        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.controlled_disposable = Disposable.empty()
Пример #7
0
    def __subscribe(self, observer):
        self.check_disposed()
        if not self.is_stopped:
            self.observers.append(observer)
            return InnerSubscription(self, observer)

        if self.exception:
            observer.on_error(self.exception)
            return Disposable.empty()

        observer.on_completed()

        return Disposable.empty()
Пример #8
0
    def _subscribe(self, observer):
        with self.lock:
            self.check_disposed()
            if not self.is_stopped:
                self.observers.append(observer)
                return InnerSubscription(self, observer)

            if self.exception:
                observer.on_error(self.exception)
                return Disposable.empty()

            observer.on_completed()
            return Disposable.empty()
Пример #9
0
 def wrapped_action(self, state):
     try:
         return action(parent._get_recursive_wrapper(self), state)
     except Exception as ex:
         if not parent._handler(ex):
             raise Exception(ex)
         return Disposable.empty()
 def wrapped_action(self, state):
     try:
         return action(parent._get_recursive_wrapper(self), state)
     except Exception as ex:
         if not parent._handler(ex):
             raise Exception(ex)
         return Disposable.empty()
Пример #11
0
            def schedule_work(_, state3):
                action(state3, inner_action)
                if is_added:
                    group.remove(d)
                else:
                    is_done[0] = True

                return Disposable.empty()
Пример #12
0
                def action2(scheduler1, state3):
                    if is_added:
                        group.remove(d)
                    else:
                        is_done[0] = True

                    recursive_action(state3)
                    return Disposable.empty()
Пример #13
0
                def action(scheduler, state=None):
                    if is_added:
                        group.remove(d)
                    else:
                        is_done[0] = True

                    recursive_action(state)
                    return Disposable.empty()
Пример #14
0
            def schedule_work(_, state3):
                action(state3, inner_action)
                if is_added:
                    group.remove(d)
                else:
                    is_done[0] = True

                return Disposable.empty()
Пример #15
0
                def action2(scheduler1, state3):
                    nonlocal is_done

                    if is_added:
                        group.remove(d)
                    else:
                        is_done = True

                    recursive_action(state3)
                    return Disposable.empty()
Пример #16
0
            def fix_subscriber(subscriber):
                """Fix subscriber to check for None or function returned to 
                decorate as Disposable"""
            
                if subscriber is None:
                    subscriber = Disposable.empty()
                elif type(subscriber) == types.FunctionType:
                    subscriber = Disposable(subscriber)

                return subscriber
Пример #17
0
                def action(scheduler, state=None):
                    nonlocal is_done

                    #print "action", scheduler1, state3
                    if is_added:
                        group.remove(d)
                    else:
                        is_done = True

                    recursive_action(state)
                    return Disposable.empty()
Пример #18
0
                def action(scheduler, state=None):
                    nonlocal is_done

                    #print "action", scheduler1, state3
                    if is_added:
                        group.remove(d)
                    else:
                        is_done = True
                    
                    recursive_action(state)
                    return Disposable.empty()
Пример #19
0
 def subscribe(observer):
     disposable = Disposable.empty()
     try:
         resource = resource_factory()
         if resource:
             disposable = resource
         
         source = observable_factory(resource)
     except Exception as exception:
         d = Observable.throw_exception(exception).subscribe(observer)
         return CompositeDisposable(d, disposable)
     
     return CompositeDisposable(source.subscribe(observer), disposable)
Пример #20
0
        def subscribe(observer):
            disposable = Disposable.empty()
            try:
                resource = resource_factory()
                if resource:
                    disposable = resource

                source = observable_factory(resource)
            except Exception as exception:
                d = Observable.throw_exception(exception).subscribe(observer)
                return CompositeDisposable(d, disposable)

            return CompositeDisposable(source.subscribe(observer), disposable)
Пример #21
0
    def subscribe(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.subject.distinct_until_changed().subscribe(on_next)
        return CompositeDisposable(subscription, connection[0], pausable)
Пример #22
0
 def __subscribe(self, observer):
     self.check_disposed()
     if not self.is_stopped:
         self.observers.append(observer)
         observer.on_next(self.value)
         return InnerSubscription(self, observer)
     
     ex = self.exception
     if ex:
         observer.on_error(ex)
     else:
         observer.on_completed()
     
     return Disposable.empty()
Пример #23
0
    def __subscribe(self, observer):
        self.check_disposed()
        if not self.is_stopped:
            self.observers.append(observer)
            observer.on_next(self.value)
            return InnerSubscription(self, observer)

        ex = self.exception
        if ex:
            observer.on_error(ex)
        else:
            observer.on_completed()

        return Disposable.empty()
Пример #24
0
    def subscribe(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.subject.distinct_until_changed().subscribe(on_next)
        return CompositeDisposable(subscription, connection[0], pausable)
Пример #25
0
    def _process_request(self, number_of_items):
        if self.enable_queue:
            #console.log('queue length', self.queue.length)

            while len(self.queue) >= number_of_items and number_of_items > 0:
                # console.log('number of items', number_of_items)
                self.subject.on_next(self.queue.shift())
                number_of_items -= 1

            if len(self.queue):
                return { "number_of_items": number_of_items, "return_value": True }
            else:
                return { "number_of_items": number_of_items, "return_value": False }

        if self.has_failed:
            self.subject.on_error(self.error)
            self.controlled_disposable.dispose()
            self.controlled_disposable = Disposable.empty()
        elif self.has_completed:
            self.subject.on_completed()
            self.controlled_disposable.dispose()
            self.controlled_disposable = Disposable.empty()

        return { "number_of_items": number_of_items, "return_value": False }
Пример #26
0
    def request(self, number):
        check_disposed(self)
        self.dispose_current_request()

        r = self._process_request(number)
        number = r["number_of_items"]
        if not r["return_value"]:
            self.requested_count = number

            def action():
                self.requested_count = 0
            self.requested_disposable = Disposable(action)

            return self.requested_disposable
        else:
            return Disposable.empty()
Пример #27
0
    def request(self, number):
        check_disposed(self)
        self.dispose_current_request()

        r = self._process_request(number)
        number = r["number_of_items"]
        if not r["return_value"]:
            self.requested_count = number

            def action():
                self.requested_count = 0

            self.requested_disposable = Disposable(action)

            return self.requested_disposable
        else:
            return Disposable.empty()
Пример #28
0
    def _subscribe(self, observer):
        with self.lock:
            self.check_disposed()
            if not self.is_stopped:
                self.observers.append(observer)
                return InnerSubscription(self, observer)

            ex = self.exception
            hv = self.has_value
            v = self.value

        if ex:
            observer.on_error(ex)
        elif hv:
            observer.on_next(v)
            observer.on_completed()
        else:
            observer.on_completed()

        return Disposable.empty()
Пример #29
0
    def _subscribe(self, observer):
        with self.lock:
            self.check_disposed()
            if not self.is_stopped:
                self.observers.append(observer)
                return InnerSubscription(self, observer)

            ex = self.exception
            hv = self.has_value
            v = self.value

        if ex:
            observer.on_error(ex)
        elif hv:
            observer.on_next(v)
            observer.on_completed()
        else:
            observer.on_completed()

        return Disposable.empty()
Пример #30
0
 def action(scheduler, state):
     notification.accept(observer)
     return Disposable.empty()
Пример #31
0
 def on_next(b):
     if b:
         connection[0] = conn.connect()
     else:
         connection[0].dispose()
         connection[0] = Disposable.empty()
 def subscribe1(o):
     o.on_next(1)
     return Disposable.empty()
 def subscribe3(o):
     o.on_completed()
     return Disposable.empty()
Пример #34
0
 def inner_action(scheduler, y):
     yy[0] = y
     return Disposable.empty()
Пример #35
0
 def subscribe3(o):
     o.on_completed()
     return Disposable.empty()
Пример #36
0
 def subscribe(o):
     o.on_completed()
     o.on_next(100)
     o.on_error("ex")
     o.on_completed()
     return Disposable.empty()
Пример #37
0
 def subscribe(observer):
     return Disposable.empty()
Пример #38
0
def test_emptydisposable():
    d = Disposable.empty()
    assert d
    d.dispose()
Пример #39
0
 def action_dispose(scheduler, state):
     """Called at dispose time. Defaults to 1000"""
     subscription[0].dispose()
     return Disposable.empty()
Пример #40
0
 def action_create(scheduler, state):
     """Called at create time. Defaults to 100"""
     source[0] = create()
     return Disposable.empty()
Пример #41
0
 def action_subscribe(scheduler, state):
     """Called at subscribe time. Defaults to 200"""
     subscription[0] = source[0].subscribe(observer)
     return Disposable.empty()
Пример #42
0
 def invoke_action(self, action, state=None):
     action(self, state)
     return Disposable.empty()
Пример #43
0
 def inner_action(scheduler, y):
     nonlocal yy
     yy = y
     return Disposable.empty()
Пример #44
0
 def subscribe1(o):
     o.on_next(1)
     return Disposable.empty()
 def inner_action(scheduler, state):
     nonlocal yy
     yy = state
     return Disposable.empty()
 def action(scheduler, state=None):
      nonlocal xx
      xx = state
      return Disposable.empty()
Пример #47
0
 def subscribe(o):
     o.on_error(ex)
     o.on_next(100)
     o.on_error('foo')
     o.on_completed()
     return Disposable.empty()
 def inner_action(scheduler, y):
     nonlocal yy
     yy = y
     return Disposable.empty()
Пример #49
0
 def subscribe2(o):
     o.on_error('exception')
     return Disposable.empty()
Пример #50
0
 def invoke_action(self, action, state=None):
     action(self, state)
     return Disposable.empty()
Пример #51
0
 def action(scheduler, state=None):
      xx[0] = state
      return Disposable.empty()
Пример #52
0
 def action(scheduler, state=None):
     nonlocal xx
     xx = state
     return Disposable.empty()
Пример #53
0
 def inner_action(scheduler, state=None):
     yy[0] = state
     return Disposable.empty()
Пример #54
0
 def inner_action(scheduler, state):
     nonlocal yy
     yy = state
     return Disposable.empty()
 def subscribe2(o):
     o.on_error('exception')
     return Disposable.empty()
Пример #56
0
 def action(scheduler, state):
     for observer in observable.observers:
         notification.accept(observer)            
     return Disposable.empty()
Пример #57
0
 def subscribe(_):
     return Disposable.empty()
Пример #58
0
 def dispose_current_request(self):
     self.requested_disposable.dispose()
     self.requested_disposable = Disposable.empty()