Python Observable.from_方法代码示例

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def main():
  Observable.from_(sources) \
    .merge_all() \
    .subscribe(lambda x: print(x)) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def run(self):
        self.socket.listen(5)

        def clients_iter():
            try:
                while True:
                    yield self.socket.accept()
            except:
                pass

        def send_start(c):
            return c[0].send(b'Asterisk Call Manager/6.6.6\r\n\r\n')

        Observable.from_(clients_iter()) \
            .subscribe(send_start) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def __init__(self, socket_client, topic='gdax'):

        self.ws = socket_client
        self.delay = 1
        self.stream = KafkaStream.consumer(topic='gdax', offset='end')
        self.source = Observable.from_(self.stream)

        super(AvroListener, self).__init__() 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def __sense_environment(self):
        Observable.from_(
            self.sensors). subscribe(
            lambda sensor: self.working_memory.append(
                Fact(
                    sensor=sensor.name,
                    data=sensor.exec(),
                    binding=sensor.binding)))
        Observable.from_(
            self.working_memory). subscribe(
            lambda fact: setattr(
                self.world_state,
                fact.binding,
                fact.data.response)) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def firstnames_from_db(file_name):
    file = open(file_name)

    # collect and push stored people firstnames
    return Observable.from_(file) \
        .flat_map(lambda content: content.split(', ')) \
        .filter(lambda name: name!='') \
        .map(lambda name: name.split()[0]) \
        .group_by(lambda firstname: firstname) \
        .flat_map(lambda grp: grp.count().map(lambda ct: (grp.key, ct))) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def frequent_firstnames_from_db(file_name):
    file = open(file_name)

    # collect and push only the frequent firstnames
    return Observable.from_(file) \
        .flat_map(lambda content: content.split(', ')) \
        .filter(lambda name: name!='') \
        .map(lambda name: name.split()[0]) \
        .group_by(lambda firstname: firstname) \
        .flat_map(lambda grp: grp.count().map(lambda ct: (grp.key, ct))) \
        .filter(lambda name_and_ct: name_and_ct[1] > 3) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def test_accepts_multiple_subscription_fields_defined_in_schema():
    # type: () -> None
    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_="yuzhi@graphql.org",
        subject="Alright",
        message="Tests are good",
        unread=True,
    )
    inbox = []
    stream.subscribe(inbox.append)
    send_important_email(email)
    assert len(inbox) == 1
    assert inbox[0][0] == email 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def test_accepts_type_definition_with_sync_subscribe_function():
    # type: () -> None
    SubscriptionType = GraphQLObjectType(
        name="Subscription",
        fields=OrderedDict(
            [
                (
                    "importantEmail",
                    GraphQLField(
                        EmailEventType, resolver=lambda *_: Observable.from_([None])
                    ),
                )
            ]
        ),
    )
    test_schema = GraphQLSchema(query=QueryType, subscription=SubscriptionType)

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

    email = Email(
        from_="yuzhi@graphql.org",
        subject="Alright",
        message="Tests are good",
        unread=True,
    )
    inbox = []
    subscription.subscribe(inbox.append)
    send_important_email(email)
    assert len(inbox) == 1
    assert inbox[0].data == {"importantEmail": None} 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def test_produces_a_payload_for_multiple_subscribe_in_same_subscription():
    # type: () -> None
    stream = Subject()
    send_important_email, subscription1 = create_subscription(stream)
    subscription2 = create_subscription(stream)[1]

    payload1 = []
    payload2 = []

    subscription1.subscribe(payload1.append)
    subscription2.subscribe(payload2.append)

    email = Email(
        from_="yuzhi@graphql.org",
        subject="Alright",
        message="Tests are good",
        unread=True,
    )

    send_important_email(email)
    expected_payload = {
        "importantEmail": {
            "email": {"from": "yuzhi@graphql.org", "subject": "Alright"},
            "inbox": {"unread": 1, "total": 2},
        }
    }

    assert payload1[0].data == expected_payload
    assert payload2[0].data == expected_payload


# Subscription Publish Phase 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def test_uses_the_subscription_schema_for_subscriptions():
    # type: () -> None
    from rx import Observable

    doc = "query Q { a } subscription S { a }"

    class Data(object):
        a = "b"
        c = "d"

    ast = parse(doc)
    Q = GraphQLObjectType("Q", {"a": GraphQLField(GraphQLString)})
    S = GraphQLObjectType(
        "S",
        {
            "a": GraphQLField(
                GraphQLString, resolver=lambda root, info: Observable.from_(["b"])
            )
        },
    )
    result = execute(
        GraphQLSchema(Q, subscription=S),
        ast,
        Data(),
        operation_name="S",
        allow_subscriptions=True,
    )
    assert isinstance(result, Observable)
    l = []
    result.subscribe(l.append)
    result = l[0]
    assert not result.errors
    assert result.data == {"a": "b"} 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def create_subscription(
    stream,  # type: Subject
    schema=email_schema,  # type: GraphQLSchema
    ast=None,  # type: Optional[Any]
    vars=None,  # type: Optional[Any]
):
    # type: (...) -> Tuple[Callable, Union[ExecutionResult, Observable]]
    class Root(object):
        class inbox(object):
            emails = [
                Email(
                    from_="joe@graphql.org",
                    subject="Hello",
                    message="Hello World",
                    unread=False,
                )
            ]

        @staticmethod
        def importantEmail():
            return stream

    def send_important_email(new_email):
        # type: (Email) -> None
        Root.inbox.emails.append(new_email)
        stream.on_next((new_email, Root.inbox))
        # stream.on_completed()

    default_ast = parse(
        """
    subscription {
      importantEmail {
        email {
          from
          subject
        }
        inbox {
          unread
          total
        }
      }
    }
  """
    )

    return (
        send_important_email,
        graphql(schema, ast or default_ast, Root, None, vars, allow_subscriptions=True),
    ) 

# 需要导入模块: from rx import Observable [as 别名]
# 或者: from rx.Observable import from_ [as 别名]
def test_produces_a_payload_per_subscription_event():
    # type: () -> None
    stream = Subject()
    send_important_email, subscription = create_subscription(stream)

    payload = []

    subscription.subscribe(payload.append)
    send_important_email(
        Email(
            from_="yuzhi@graphql.org",
            subject="Alright",
            message="Tests are good",
            unread=True,
        )
    )
    expected_payload = {
        "importantEmail": {
            "email": {"from": "yuzhi@graphql.org", "subject": "Alright"},
            "inbox": {"unread": 1, "total": 2},
        }
    }

    assert len(payload) == 1
    assert payload[0].data == expected_payload

    send_important_email(
        Email(
            from_="hyo@graphql.org",
            subject="Tools",
            message="I <3 making things",
            unread=True,
        )
    )
    expected_payload = {
        "importantEmail": {
            "email": {"from": "hyo@graphql.org", "subject": "Tools"},
            "inbox": {"unread": 2, "total": 3},
        }
    }

    assert len(payload) == 2
    assert payload[-1].data == expected_payload

    # The client decides to disconnect
    stream.on_completed()

    send_important_email(
        Email(
            from_="adam@graphql.org",
            subject="Important",
            message="Read me please",
            unread=True,
        )
    )

    assert len(payload) == 2