def game(self, gid): all_game_times = self.all_game_times() # print(all_game_times) games = list(filter(lambda g: g.id == gid, all_game_times)) if len(games) == 0: return None gametime = games[0].time op = Operation(schema.Query) games = op.games_connection(first=60, at_or_after_time=gametime, before_time=gametime + timedelta(hours=12)) games.nodes.id() home_team = games.nodes.home_team() home_team.region_name() home_team.nickname() home_team.abbreviation() home_team.name() away_team = games.nodes.away_team() away_team.region_name() away_team.nickname() away_team.abbreviation() away_team.name() status = games.nodes.status() status.home_team_points() status.away_team_points() status.phase() status.quarter() games.nodes.stadium().__fields__('name') games.nodes.stadium().address().__fields__('locality', 'administrative_area_abbreviation') games = self._execute(op).games_connection.nodes return list(filter(lambda g: g.id == gid, games))[0]
def get_pairs_page(self, pairs_filter, skip, **kwargs): op = Operation(schema.Query) pairs = op.pairs( where=pairs_filter, skip=skip, first=self.page_size, **kwargs ) pairs.id() pairs.token0().symbol() pairs.token0().id() pairs.token0().decimals() pairs.token0_price() pairs.volume_token0() pairs.reserve0() pairs.token1().symbol() pairs.token1().id() pairs.token1().decimals() pairs.token1_price() pairs.volume_token1() pairs.reserve1() pairs.volume_usd() pairs.reserve_eth() pairs.reserve_usd() while True: data = self.endpoint(op) if 'errors' not in data.keys(): break print("Error getting data. Retrying in 2 secs.") sleep(2) query = op + data return query.pairs if hasattr(query, 'pairs') else []
def get_wallet(self, pk: str, all_fields: bool = False) -> dict: """Gets the wallet for the specified Public Key. Args: pk: A Public Key corresponding to a currently installed wallet. all_fields: return all available fields in response Returns: dict, the "data" field of the JSON Response. """ default_fields = [ "balance", "nonce", "receipt_chain_hash", "delegate", "voting_for", "staking_active", "private_key_path", ] op = Operation(mina_schema.query) op.wallet(public_key=pk) if not all_fields: op.wallet.__fields__(*default_fields) res = self._send_sgqlc_query(op) return res["data"]
def send_payment( self, to_pk: str, from_pk: str, amount: Currency, fee: Currency, memo: str ) -> dict: """Send a payment from the specified wallet to specified target wallet. Args: to_pk: The target wallet where funds should be sent from_pk: The installed wallet which will finance the payment amount: Currency instance. The amount of Mina to send fee: Currency instance. The transaction fee that will be attached to the payment memo: memo to attach to the payment Returns: dict, the "data" field of the JSON Response. """ input_dict = { "from": from_pk, "to": to_pk, "fee": fee.nanominas(), "memo": memo, "amount": amount.nanominas(), } send_payment_input = mina_schema.SendPaymentInput(input_dict) op = Operation(mina_schema.mutation) op.send_payment(input=send_payment_input) res = self._send_sgqlc_query(op) return res["data"]
def get_commit_history(self, from_sha: str, to_sha: str) -> List[Commit]: request_uuid = ( f"commit-history:{self.repo_owner}-{self.repo_name}-{self.branch}" f"-{from_sha}-{to_sha}") query = Operation(schema.Query) commits = (query.repository( owner=self.repo_owner, name=self.repo_name).object( expression=self.branch).__as__(Commit).history( first=100).nodes) commits.__fields__("id", "oid", "message", "changed_files") commits.author.__as__(GitActor).name() prs = commits.associated_pull_requests(first=5).nodes prs.__fields__("id", "number", "url", "merged_at", "base_ref_name") prs.merged_by.__as__(User).name() prs.author.__as__(User).name() pr_commits = prs.commits(first=100) pr_commits.__fields__("total_count") pr_commits.nodes.commit.__fields__("oid", "url") files = prs.files(first=100) files.__fields__("total_count") files.nodes.__fields__("path", "additions", "deletions") response = self._get_response(query, request_uuid) commits_all = (query + response).repository.object.history.nodes result, finished = self._filter_commits_and_prs( commits_all, from_sha, to_sha) return result
def get_pair(self, id, **kwargs): op = Operation(schema.Query) pair = op.pair(id=id, **kwargs) pair.id() pair.token0().symbol() pair.token0().id() pair.token0().decimals() pair.token0_price() pair.volume_token0() pair.reserve0() pair.token1().symbol() pair.token1().id() pair.token1().decimals() pair.token1_price() pair.volume_token1() pair.reserve1() pair.volume_usd() pair.reserve_eth() pair.reserve_usd() while True: try: data = self.endpoint(op) except URLError: data = {} if 'errors' not in data.keys() and \ 'data' in data.keys() and \ 'pair' in data['data'].keys() and \ 'reserve0' in data['data']['pair'].keys() and \ 'reserve1' in data['data']['pair'].keys(): break print("Error getting data. Retrying in 2 secs.") sleep(2) query = op + data return query.pair if hasattr(query, 'pair') else []
def get_pairs_page(self, pairs_filter, last_id, first, **kwargs): op = Operation(schema.Query) if last_id is not None: pairs_filter.update({"id_gt": last_id}) pairs = op.pairs(where=pairs_filter, first=first, **kwargs) pairs.id() pairs.token0().symbol() pairs.token0().id() pairs.token0().decimals() pairs.token0_price() pairs.volume_token0() pairs.reserve0() pairs.token1().symbol() pairs.token1().id() pairs.token1().decimals() pairs.token1_price() pairs.volume_token1() pairs.reserve1() pairs.volume_usd() pairs.reserve_eth() pairs.reserve_usd() while True: data = self.endpoint(op) if 'errors' not in data.keys(): break print("Error getting data. Retrying in 2 secs.") print(data['errors']) sleep(2) query = op + data return query.pairs if hasattr(query, 'pairs') else []
def get_block_by_state_hash( self, state_hash: str, all_fields: bool = False ) -> dict: """Get the block data by state hash. Returns block height, block creator and snarkJobs Args: state_hash: state hash all_fields: return all available fields in response Returns: dict, the "data" field of the JSON Response. """ default_fields = ["creator", "protocol_state", "snark_jobs"] op = Operation(mina_schema.query) op.block(state_hash=state_hash) if not all_fields: op.block.__fields__(*default_fields) res = self._send_sgqlc_query(op) return res["data"]
def get_all_clients(self) -> List[Device]: dev_list = [] page = 1 end_page = 2 while end_page >= page: op = Operation(schema.NyansaGraphQLQuery) dev = op.device_list(uuids=self.cfg.macs, page=page, page_size=500, sort_by=['uuid']) dev.page() dev.page_count() dev.devices() dev.devices.uuid() dev.devices.ip_address() dev.devices.hostname() dev.devices.ap_name() dev.devices.ap_mac_addr() dev.devices.essid() dev.devices.snr_db() dev.devices.last_updated() dev.devices.voyance_url() data = self.ep(op) devinfo = (op + data).device_list for d in devinfo.devices: # type: Device dev_list.append(d) end_page = devinfo.page_count print(f'Run {page} of {end_page} - Length {len(dev_list)}') page += 1 sleep(.5) return dev_list
def get_list(self, fields: list = [], **kwargs) -> Generator[Interview, None, None]: where = InterviewFilter(**kwargs) take = 20 skip = 0 filtered_count = 21 if not fields: fields = [ 'id', 'questionnaire_id', 'questionnaire_version', 'assignment_id', 'responsible_id', 'errors_count', 'status', ] while skip < filtered_count: op = Operation(headquarters_schema.HeadquartersQuery) q = op.interviews(take=take, skip=skip, where=where) q.__fields__('filtered_count') q.nodes.__fields__(*fields) cont = self.endpoint(op) errors = cont.get('errors') if errors: raise GraphQLError(errors[0]['message']) res = (op + cont).interviews filtered_count = res.filtered_count yield from res.nodes skip += take
def create_bid(postcode: int, **kwargs) -> str: """ Query the helpling API to create a new bid. Then, set the given parameters (or default values configured in ``DEFAULT_SEARCH_PARAMETERS``) to it. This is the first step to scraping offers for a region. :param postcode: The postcode for which to request a new bid :param kwargs: The parameters to set for the search. :return: The bidCode of the created bid """ response = requests.post(BASE_URL + "v1/bids", { "bid[postcode]": postcode, "bid[checkout_version]": 1 }) bid_id = response.json().get("data").get("code") if bid_id is None: raise Exception("Bid for postcode " + str(postcode) + " could not be created: " + response.text) print("Create bid for " + str(postcode) + " (" + bid_id + "): OK") op = Operation(helpling_schema.Mutation) op.transition_bid_to_provider_selection(**{ **DEFAULT_SEARCH_PARAMETERS, **kwargs, "bid_code": bid_id }) result = gql_endpoint(op).get("data").get( "transitionBidToProviderSelection") if result.get("success") is False: raise Exception("Bid " + bid_id + " could not be parametrized: " + result.get("errors")) print("Parametrize bid " + bid_id + ": OK") return bid_id
def get_candidates_for_bid( bid_id: str) -> List[helpling_schema.DecoratedPotentialCandidateEdge]: """ Query the API for all (i.e. the first 1000) candidates for a given bid. The bid must have been parametrized already. Note that not all fields are actually requested from the backend. :param bid_id: Id of an already-parametrized bid :return: First 1000 candidates available for the bid """ op = Operation(helpling_schema.Query) candidates = op.customer_bid(code=bid_id).potential_candidates(first=1000) candidates.edges.node.price_per_hour() provider = candidates.edges.node.provider provider.__fields__("id", "firstname", "shortname", "default_profile_image", "pets", "windows", "ironing", "ratings_received_count", "verification_level", "documents", "performed_cleanings_count", "language_skills", "instabook_enabled") provider.avg_rating.total() provider.experience.__fields__() provider.distance_to_bid(bid_code=bid_id) data = gql_endpoint(op) return (op + data).customer_bid.potential_candidates.edges
def generateGQL(initViewer,currentUser,followingEndCursor,followerEndCursor): op = Operation(Query) if initViewer: viewer = op.viewer() viewer.login() viewer.isSiteAdmin() viewer.email() viewer.name() viewer.updatedAt() viewer.company() user = op.user(login=currentUser) if followingEndCursor == "": following = user.following(first=100) elif followingEndCursor == None: following = user.following(first=100) else: following = user.following(first=100,after=followingEndCursor) if followerEndCursor == "": followers = user.followers(first=100) elif followerEndCursor == None: followers = user.followers(first=100) else: followers = user.followers(first=100, after=followerEndCursor) initQueryNodes(following) initQueryNodes(followers) return op
def push_updates(self): """ push update buffer to database in order to be rendered by the graphics :return: """ times, updates = zip(*self._update_buffer) intersections, distances, directions = zip(*updates) print(times) print(intersections) op = Operation(schema.Mutation) update = op.push_update_buffer(times=times, intersections=intersections, distances=distances, directions=directions, search_algorithm=self._search_algorithm) update.time() new_car_loc = update.new_car_loc() new_car_loc.intersection() new_car_loc.distance() new_car_loc.direction() print(op) data = endpoint(op) result = op + data print(result) return result
def get_map(self): """ get the map from the server """ op = Operation(schema.Query) search_tf = op.search_tf() road_graph = search_tf.road_graph() road_graph.name() connections = road_graph.connections() connections.index() connections.start() connections.end() connections.start_name() connections.end_name() connections.length() connections.direction() intersections = road_graph.intersections() intersections.index() intersections.name() intersections.x() intersections.y() intersections.connections() start_state = road_graph.start_state() start_state.last_intersection() start_state.distance_since() start_state.direction() data = endpoint(op) result = op + data self._road_graph = result.search_tf.road_graph return self._road_graph
def fetch_gql_speech(speech_id): op = Operation(Query) speech = op.speech(filter=_SpeechFilter({'id': speech_id})) speech.id() speech.order_in_minutes() minutes = speech.belonged_to_minutes() minutes.id() minutes.name() minutes.ndl_min_id() member = speech.be_delivered_by_member() member.id() member.name() res = gql_client.endpoint(op) speech = (op + res).speech[0] minutes = speech.belonged_to_minutes member = speech.be_delivered_by_member speech_info = {'speech_id': speech.id} if minutes: speech_info['minutes_id'] = minutes.id speech_info['minutes_name'] = minutes.name speech_info['minutes_politylink_url'] = to_politylink_url(minutes.id) if minutes.ndl_min_id: speech_info[ 'speech_ndl_url'] = 'https://kokkai.ndl.go.jp/txt/{0}/{1}'.format( minutes.ndl_min_id, speech.order_in_minutes) if member: speech_info['member_id'] = member.id speech_info['member_name'] = member.name speech_info['member_image_url'] = to_politylink_url( member.id, domain='image.politylink.jp') speech_info['member_politylink_url'] = to_politylink_url(member.id) return speech_info
def get_swaps_page(self, transactions_filter, skip): op = Operation(schema.Query) transactions = op.transactions( where=transactions_filter, skip=skip, first=self.page_size ) transactions.block_number() transactions.swaps().log_index() transactions.swaps().pair().token0().symbol() transactions.swaps().pair().token1().symbol() transactions.swaps().amount0_in() transactions.swaps().amount1_in() transactions.swaps().amount0_out() transactions.swaps().amount1_out() transactions.swaps().amount_usd() while True: data = self.endpoint(op) if 'errors' not in data.keys(): break print("Error getting data. Retrying in 2 secs.") sleep(2) query = op + data if hasattr(query, 'transactions'): return query.transactions return []
def create_operation(owner, name, labels=(), issue_states=(), pr_states=()): op = Operation(schema.Query) repo = op.repository(owner=owner, name=name) repo.labels(first=100).nodes.__fields__( name=True, color=True, ) repo.milestones(first=100).nodes.__fields__( id=True, state=True, due_on=True, title=True, description=True, ) repo.projects(first=100).nodes.__fields__( id=True, number=True, name=True, state=True, ) select_issues(repo, labels, issue_states) select_pull_requests(repo, labels, pr_states) return op
def schedule(self, for_week=None): op = Operation(schema.Query) season = op.seasons_connection(last=1) season.nodes.named_time_ranges_connection(last=25).nodes.__fields__('id', 'name', 'time', 'subseason', 'duration_milliseconds') games = season.nodes.games_connection(last=80) games.nodes.time() games.nodes.named_time_range().id() games.nodes.home_team().__fields__('abbreviation', 'name', 'region_name', 'nickname') games.nodes.away_team().__fields__('abbreviation', 'name', 'region_name', 'nickname') games.nodes.status().__fields__('home_team_points', 'away_team_points', 'phase') games.nodes.availability().short_name() result = self._execute(op) weeks = {} season = result.seasons_connection.nodes[0] for week in season.named_time_ranges_connection.nodes: weeks[week.id] = (week, []) for game in season.games_connection.nodes: weeks[game.named_time_range.id][1].append(game) if for_week is not None: for week_id, (week, games) in weeks.items(): if week.time < for_week < week.time + timedelta(milliseconds=week.duration_milliseconds): return week, games return weeks
def standings(self): op = Operation(schema.Query) teams = op.teams_connection(first=8) division = teams.nodes.division() division.name() division.id() division.abbreviation() teams.nodes.abbreviation() teams.nodes.nickname() teams.nodes.region_name() season = teams.nodes.seasons_connection(last=1) standing = season.edges.standing() standing.__fields__() result = self._execute(op) standings = {} divs = {} for team in result.teams_connection.nodes: # Some hoop-jumping to use a single division object as the key and get things grouped nicely if team.division.id not in divs: divs[team.division.id] = team.division key = divs[team.division.id] if key not in standings: standings[key] = [] standings[key].append(team) def standings_key(team): return team.seasons_connection.edges[0].standing.division_rank for div in standings: standings[div] = sorted(standings[div], key=standings_key) return standings
def get_metric_data(self, label: str, source_id: str) -> List[MetricData]: op = Operation(Query) fields = list(MetricData._ContainerTypeMeta__fields.keys()) fields.remove("id") op.metric_data(source_id=source_id, label=label).nodes().__fields__(*fields) return (op + self.run(op)).metric_data.nodes
def _get_orders_page(self, orders_filter, skip): op = Operation(schema.Query) orders = op.orders(where=orders_filter, skip=skip, first=self.page_size) orders.id() orders.order_id() orders.buy_token().symbol() orders.sell_token().symbol() orders.max_sell_amount() orders.price_numerator() orders.price_denominator() orders.owner().id() orders.from_epoch() orders.until_epoch() orders.cancel_epoch() orders.create_epoch() orders.delete_epoch() orders.from_batch_id() orders.until_batch_id() orders.bought_volume() orders.sold_volume() orders.tx_hash() data = self.http_endpoint(op) query = op + data return query.orders if hasattr(query, 'orders') else []
def remove_protection(self, protection_rule_id): op = Operation(schema.Mutation) op.delete_branch_protection_rule(input=schema.DeleteBranchProtectionRuleInput( branch_protection_rule_id=protection_rule_id )) if settings.apply: GitHubGraphQL().call(op)
async def listen_sync_update(self, callback): """Creates a subscription for Network Sync Updates.""" op = Operation(mina_schema.subscription_type) op.new_sync_update() variables = {} query = bytes(op).decode("utf-8") await self._graphql_subscription(query, variables, callback)
def get_layers_as_feature_collection(self): layer_gw_op = Operation(schema.Query) gw_layer_op = layer_gw_op.get_layers() self.get_all_properties_as_feature_collection(gw_layer_op) query_plus_data = send_query(endpoint=self.endpoint, query=layer_gw_op, logger=self.logger) return query_plus_data.get_layers
def _retrieve(cls, fn, **params): op = Operation(schema.Query) fields = dict(getattr(schema.Query, fn).args) for p in params: if p != 'select' and p not in fields: raise ValueError("%s does not support the '%s' parameter" % (fn, p)) if 'filter' in dict(getattr(schema.Query, fn).args): filter_fields = dict(getattr( schema.Query, fn).args)['filter'].type.__field_names__ for f in params.get('filter', {}): if f not in filter_fields: raise ValueError("%s does not support filtering on '%s'." % (fn, f)) update_subfields(op, fn, params, query=schema.Query) logger.debug(op.__to_graphql__(auto_select_depth=1)) from mage import endpoint result = endpoint(op.__to_graphql__(auto_select_depth=1)) if 'errors' in result: for e in result['errors']: logger.error(e['message']) if e['message'] == 'Token has expired': raise RuntimeError( 'Token expired. Call mage.connect() again.') if 'data' in result and result['data']: data = getattr((op + result), fn) if getattr(schema.Query, fn).type == schema.AWSJSON: data = json.loads(data) items = data.get('items', [data]) else: items = getattr(data, 'items', None) if items is None: if hasattr(data, 'next_token'): raise RuntimeError( "'next_token' is present but 'items' is missing.") else: # usually results are like {'data': {'items': [something]}} # but sometimes it is {'data': something} # that case is covered here items = [data] items = list(filter(None, items)) next_token = getattr(data, 'next_token', None) if next_token: logger.debug("More data available") else: logger.debug("No More data") return ListObject(cls=cls, fn=fn, params=params, items=items, next_token=next_token)
def build_merge(ids: List[str]): op = Operation(Mutation) for i, ident in enumerate(ids): op.merge_pull_request( input=MergePullRequestInput(pull_request_id=ident), __alias__=f'merge_{i}').pull_request.title() return op
def gq_repository(self) -> schema.Repository: op = Operation(schema.Query) r = op.repository(owner=self.organization.login, name=self.name) r.id() r.branch_protection_rules(first=100) r.branch_protection_rules.nodes.id() r.branch_protection_rules.nodes.pattern() data = GitHubGraphQL().call(op) return (op + data).repository
def new_tweet(self, content, tags=None): if tags is None: tags = [] content = content.replace("#", "") op = Operation(Mutation) op.new_tweet(text=content, tags=tags) op.new_tweet.id() response = do_op(op, self.token) return response.new_tweet.id
def test_create_graphql_query_programmatically(): query = Operation(Query) query.missions() response = requests.post("https://api.spacex.land/graphql/", json={'query': str(query)}) assert response.status_code == 200 assert len(response.json()['data']['missions']) == 10