def test_scalar_serializer_can_be_set_on_initialization():
schema = build_schema(type_defs)
scalar = ScalarType("DateInput", serializer=serialize_date)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.serialize is serialize_date
def test_scalar_literal_parser_can_be_set_on_initialization():
schema = build_schema(type_defs)
scalar = ScalarType("DateInput", literal_parser=parse_date_literal)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.parse_literal is parse_date_literal
def test_scalar_value_parser_can_be_set_on_initialization():
schema = build_schema(type_defs)
scalar = ScalarType("DateReadOnly", value_parser=parse_date_str)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateReadOnly")
assert schema_scalar.parse_value is parse_date_str
def test_default_literal_parser_is_used_to_extract_value_str_from_ast_node():
dateinput = ScalarType("DateInput")
dateinput.set_value_parser(parse_date_value)
schema = make_executable_schema(type_defs, query, dateinput)
result = graphql_sync(
schema, """{ testInput(value: "%s") }""" % TEST_DATE_SERIALIZED)
assert result.errors is None
assert result.data == {"testInput": True}
def test_setting_scalar_value_parser_doesnt_override_already_set_literal_parser(
):
schema = build_schema(type_defs)
scalar = ScalarType("DateInput")
scalar.set_literal_parser(parse_date_literal)
scalar.set_value_parser(parse_date_str)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.parse_value is parse_date_str
assert schema_scalar.parse_literal is parse_date_literal
class SchemaCreator:
data = DataStorage()
query = QueryType()
account = FederatedObjectType("Account")
bundle = FederatedObjectType("Bundle")
patient = FederatedObjectType("Patient")
text = FederatedObjectType("Narrative")
human_name = ScalarType("HumanName")
def __init__(self):
self.ds = DataStorage()
def getSchema(self):
manager = FederatedManager(
schema_sdl_file='schema/fhir_schema_4_0_0.graphql',
query=self.query,
)
@self.human_name.serializer
def serialize_datetime(value):
return HumanName(value)
@self.query.field("Patient")
def resolve_patient(obj, info, **kwargs):
return Patient(obj, info=self.data.getPatient(**kwargs)[0])
@self.query.field("Account")
def resolve_account(*_, **kwargs):
return Account(**kwargs)
@self.query.field("ActivityDefinition")
def resolve_account(*_, **kwargs):
return Account(**kwargs)
@self.query.field("AccountList")
def resolve_account_list(obj, info):
alist = AccountList(obj, info)
return [alist,]
@self.account.resolve_references
def resolve_accounts(obj, info):
return AccountList(name="test")
@self.patient.resolve_reference
def resolve_patient(obj, info):
return Patient(obj, info)
manager.add_types(self.account, self.bundle, self.patient, self.text)
manager.add_types(bundle_enum_schema)
manager.add_types(snake_case_fallback_resolvers, fallback_resolvers)
return manager.get_schema()
def test_scalar_value_parser_can_be_set_with_setter():
schema = build_schema(type_defs)
scalar = ScalarType("DateReadOnly")
scalar.set_value_parser(parse_date_str)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateReadOnly")
assert schema_scalar.parse_value is parse_date_str
def test_scalar_serializer_can_be_set_with_setter():
schema = build_schema(type_defs)
scalar = ScalarType("DateInput")
scalar.set_serializer(serialize_date)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.serialize is serialize_date
def test_scalar_literal_parser_can_be_set_with_setter():
schema = build_schema(type_defs)
scalar = ScalarType("DateInput")
scalar.set_literal_parser(parse_date_literal)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.parse_literal is parse_date_literal
def test_setting_scalar_value_parser_sets_default_literal_parsers_if_none_is_set(
):
schema = build_schema(type_defs)
scalar = ScalarType("DateInput")
scalar.set_value_parser(parse_date_value)
scalar.bind_to_schema(schema)
schema_scalar = schema.type_map.get("DateInput")
assert schema_scalar.parse_value is parse_date_value
assert schema_scalar.parse_literal
from datetime import datetime
from ariadne import ScalarType
datetime_scalar = ScalarType("Datetime")
@datetime_scalar.serializer
def serialize_datetime(value):
if isinstance(value, datetime):
return value.timestamp()
elif isinstance(value, str):
return datetime.fromisoformat(value).timestamp()
@datetime_scalar.value_parser
def parse_datetime_value(value):
assert value is not None, "There was a null value passed into a datetime creator"
return datetime.utcfromtimestamp(value)
@datetime_scalar.literal_parser
def parse_datetime_literal(ast):
value = float(ast.value)
return parse_datetime_value(value)
from dateutil import parser
from ariadne import ScalarType
from graph.graphql import Resolver
def serialize_datetime(value):
return value.isoformat()
def parse_datetime_value(value):
if value:
return parser.parse(value)
datetime_scalar = ScalarType("Datetime",
serializer=serialize_datetime,
value_parser=parse_datetime_value)
Resolver(datetime_scalar)
}
type Query {
allTodos: [Todo]!
}
type Mutation {
login(username: String!, password: String!): Login
refreshToken(token: String!): Login
createTodo(title: String!): Todo!
updateTodo(uuid: String!, completed: Boolean!): Todo!
deleteTodo(uuid: String!): Todo!
}
""" + todo_type_defs)
uuid_scalar = ScalarType("Uuid")
@uuid_scalar.serializer
def serialize_uuid(value):
return str(value.hex)
mutation = MutationType()
@mutation.field("login")
def resolve_login(_, info, username, password):
user = None
user = authenticate(username=username, password=password)
if user:
# pylint: disable=import-error
from graphql.language.ast import (StringValueNode, BooleanValueNode,
IntValueNode, FloatValueNode, ListValueNode,
ObjectValueNode)
from ariadne import ScalarType
GENERIC_SCALAR = ScalarType('GenericScalar')
@GENERIC_SCALAR.serializer
def serialize_genericscalar(value):
return value
@GENERIC_SCALAR.value_parser
def parse_genericscalar_value(value):
return value
@GENERIC_SCALAR.literal_parser
def parse_genericscalar_literal(ast):
if isinstance(ast, (StringValueNode, BooleanValueNode)):
return ast.value
if isinstance(ast, IntValueNode):
return int(ast.value)
if isinstance(ast, FloatValueNode):
return float(ast.value)
if isinstance(ast, ListValueNode):
return [parse_genericscalar_literal(value) for value in ast.values]
if isinstance(ast, ObjectValueNode):
objType = ObjectType(obj)
for fld in resolvers['Object'][obj]:
objType.set_field(fld, resolvers['Object'][obj][fld])
all_resolvers.append(objType)
# Map resolver functions to Mutation fields using MutationType
if 'Mutation' in resolvers and len(resolvers['Mutation']) > 0:
mutation = MutationType()
for m in resolvers['Mutation']:
mutation.set_field(m, resolvers['Mutation'][m])
all_resolvers.append(mutation)
# Map resolver functions to custom scalars using ScalarType
if 'Scalar' in resolvers and len(resolvers['Scalar']) > 0:
for scalar in resolvers['Scalar']:
scalarType = ScalarType(scalar)
scalarType.set_serializer(resolvers['Scalar'][scalar]['serializer'])
scalarType.set_literal_parser(
resolvers['Scalar'][scalar]['literal_parser'])
scalarType.set_value_parser(
resolvers['Scalar'][scalar]['value_parser'])
all_resolvers.append(scalarType)
# Create executable GraphQL schema
schema = make_executable_schema(type_defs, all_resolvers)
# --- ASGI app
# Create an ASGI app using the schema, running in debug mode
# Set context with authenticated graphql client.
app = GraphQL(schema, debug=True, context_value={})
def resolve_test_serialize(*_):
return TEST_DATE
@query.field("testInput")
def resolve_test_input(*_, value):
assert value == TEST_DATE
return True
@query.field("testInputValueType")
def resolve_test_input_type(*_, value):
return value
datereadonly = ScalarType("DateReadOnly")
@datereadonly.serializer
def serialize_date(date):
return date.strftime("%Y-%m-%d")
dateinput = ScalarType("DateInput")
@dateinput.value_parser
def parse_date_value(formatted_date):
parsed_datetime = datetime.strptime(formatted_date, "%Y-%m-%d")
return parsed_datetime.date()
from ariadne import (QueryType, ScalarType)
from crud.user import (get_all_users, find_user_by_id, get_all_users_count,
find_user_by_email)
user_query = QueryType()
UUID_scalar = ScalarType("UUID")
datetime_scalar = ScalarType("Datetime")
@datetime_scalar.serializer
def serialize_datetime(value):
return value.isoformat()
@UUID_scalar.serializer
def serialize_uuid(value):
return str(value)
@user_query.field("users")
async def resolve_users(_, info, current_user=None, **kwargs):
users = await get_all_users(**kwargs)
total_count = await get_all_users_count()
users = [dict(user) for user in users]
return {"users": users, "total_count": total_count}
@user_query.field("user")
async def resolve_user(_, info, current_user=None, **kwargs):
email = kwargs.get("email", None)
user_id = kwargs.get("id", None)
def create_app():
app = Flask(__name__)
mongo = MongoClient(os.environ["MONGO_URI"])
type_defs = load_schema_from_path('app/graphql/schema.graphql')
query = ObjectType("Query")
mutation = ObjectType("Mutation")
user = ObjectType("User")
registered = ObjectType("Registered")
dateScalar = ScalarType("Datetime")
bindables = [query, mutation, user, registered, dateScalar]
@dateScalar.serializer
def serialize_dateScalar(value):
"""Serialize custom DateScalar scalar for graphql-schema."""
return value.isoformat()
@query.field("user")
def resolve_user(_, info, _id):
#TODO: maybe this can be a decorator?
status = False
error = {"message": "could not get users"}
payload = {"status": status, "error": error}
with mongo:
try:
user = map(ex.prepare,
mongo.db.users.find({"_id": ObjectId(_id)}))
payload["user"] = user
payload["status"] = True
payload["error"] = None
return payload
except Exception as e:
print(e)
payload["error"]["message"] = "could not get user"
return payload
@query.field("getUsers")
def resolve_get_users(_, info):
status = False
error = {"message": "could not get users"}
payload = {"status": status, "error": error}
with mongo:
try:
users = []
if mongo.db.users.count_documents({}) >= 1:
for user in mongo.db.users.find({}):
ex.prepare(user)
users.append(user)
payload["error"] = None
payload["status"] = True
else:
payload["error"]["message"] = "No users in database"
payload["status"] = False
payload["user"] = users
except Exception as e:
print(e)
payload["error"]["message"] = "Could not get users"
return payload
#TODO: Implement lambda functions in method
@mutation.field("registerLunch")
def resolve_register_lunch(_, info, nickname, email, _id):
"""Adds timestamp for registration to the database"""
new_timestamp = datetime.datetime.utcnow()
if new_timestamp.isoweekday() < 6:
new_timestamp = new_timestamp.strftime("%Y-%m-%d")
registered = {"_id": ObjectId(), "timestamp": new_timestamp}
user = {
"_id": ObjectId(_id),
"nickname": nickname,
"email": email,
"registered": registered
}
if ex.get_user(nickname, email, mongo):
return ex.register_lunch(user, mongo, True)
else:
return ex.register_lunch(user, mongo)
return {
'status': False,
'error': {
'message': 'lunch is only available on weekdays'
}
}
@mutation.field("deleteUser")
def resolve_deleteUser(_, info, _id):
"""Deletes specified entry
Args:
_id (str): document id of user to delete.
"""
return ex.delete_user(_id, mongo)
@mutation.field("deleteTimestamp")
def resolve_deleteTimestamp(_, info, user_id, timestamp_id):
"""Deletes specified timestamp for a user
Args:
user_id (str): document id of user.
timestamp_id (str): id of date to delete.
"""
return ex.delete_timestamp(user_id, timestamp_id, mongo)
@user.field("registered")
def resolve_registered(payload, info):
registered = []
for timestamp in payload["registered"]:
registered.append(timestamp)
return registered
schema = make_executable_schema(type_defs, bindables)
@app.errorhandler(AuthError)
def handle_auth_error(exception):
"""Returns response from authorization error."""
response = jsonify(exception.error)
response.status_code = exception.status_code
return response
@app.route("/graphql", methods=["GET"])
#@cross_origin(send_wildcard=True, headers=["Content-type", "Authorization"])
@cross_origin()
#@requires_auth()
#@requires_scope('developer')
def graphql_playground():
return PLAYGROUND_HTML, 200
@app.route("/graphql", methods=["POST"])
#@cross_origin(send_wildcard=True, headers=["Content-type", "Authorization"])
@cross_origin()
#@requires_auth()
def graphql_server():
data = request.get_json()
success, result = graphql_sync(schema,
data,
context_value=None,
debug=app.debug)
status_code = 200 if success else 400
return jsonify(result), status_code
return app
from ariadne import ScalarType
rank_value = ScalarType("RankValue")
@rank_value.serializer
def serialize_rank(rank):
return str(rank)
@rank_value.value_parser
def parse_rank_value(rank):
if "." in rank:
return float(rank)
return int(rank)
bindables = [rank_value]
import json
from ariadne import ScalarType
json_scalar = ScalarType("JSON")
datetime_scalar = ScalarType("DateTime")
@datetime_scalar.serializer
def serialize_datetime(value):
# pendulum instance
return value.isoformat()
@json_scalar.serializer
def serialize_json(value):
if value is None:
return None
return json.dumps(value)
@json_scalar.value_parser
def parse_json(value):
if value is None:
return None
return json.loads(value)
scalar_types = [datetime_scalar, json_scalar]
from datetime import time
from typing import Any
from django.utils import formats
from django.utils.translation import gettext_lazy as _
from ariadne import ScalarType
from ariadne_django.scalars.utils.parsers import parse_value
time_input_formats = formats.get_format_lazy("TIME_INPUT_FORMATS")
time_scalar = ScalarType("Time")
@time_scalar.serializer
def serialize_time(value: time) -> str:
return value.isoformat()
@time_scalar.value_parser
def parse_time_value(value: Any) -> time:
parsed_value = parse_value(value, time_input_formats)
if not parsed_value:
raise ValueError(_("Enter a valid time."))
return parsed_value.time()
def test_attempt_bind_scalar_to_undefined_type_raises_error():
schema = build_schema(type_defs)
scalar = ScalarType("Test")
with pytest.raises(ValueError):
scalar.bind_to_schema(schema)
from decimal import Decimal, InvalidOperation
from django.utils.formats import number_format, sanitize_separators
from ariadne import ScalarType
decimal_scalar = ScalarType("Decimal")
@decimal_scalar.serializer
def serialize_decimal(value: Decimal) -> str:
return number_format(value)
@decimal_scalar.value_parser
def parse_decimal_value(value: str) -> Decimal:
if not isinstance(value, str):
raise InvalidOperation("Decimal must be a string")
return Decimal(sanitize_separators(value))
"""GraphQL resolvers."""
import asyncio
from ariadne import QueryType, ObjectType, make_executable_schema, ScalarType, upload_scalar, MutationType, SubscriptionType
from aocrecs.logic import (search, metaladder, report, search_options, events,
matches, stats as stat, maps, civilizations, users,
odds, playback, market)
from aocrecs.schema import TYPE_DEFS
from aocrecs.upload import add_rec
# Unhelpful rules for resolver boilerplate.
# pylint: disable=unused-argument, missing-function-docstring, invalid-name, redefined-builtin
datetime_ = ScalarType('Datetime')
dict_ = ScalarType('Dict')
@datetime_.serializer
def serialize_datetime(value):
"""Serialize a datetime value."""
return str(value)
query = QueryType()
mutation = MutationType()
map_ = ObjectType('Map')
civilization = ObjectType('Civilization')
stats = ObjectType('Stats')
match = ObjectType('Match')
player = ObjectType('Player')
research = ObjectType('Research')
def test_attempt_bind_scalar_to_invalid_schema_type_raises_error():
schema = build_schema(type_defs)
scalar = ScalarType("Query")
with pytest.raises(ValueError):
scalar.bind_to_schema(schema)
import calendar
from datetime import datetime
from ariadne import ScalarType
posix_time_scalar = ScalarType("PosixTime")
@posix_time_scalar.serializer
def serialize_posix_time(value: datetime) -> int:
return calendar.timegm(value.timetuple())
# middleware
middleware = [
Middleware(AuthenticationMiddleware, backend=TokenAuthenticationBackend())
]
# GraphQL
schema_path = (
pathlib.Path(__file__).parent.absolute().joinpath("graphql", "schema.graphql")
)
type_defs = load_schema_from_path("saltapi/graphql/schema.graphql")
datetime_scalar = ScalarType("Datetime")
datetime_scalar.set_serializer(scalars.serialize_datetime)
datetime_scalar.set_value_parser(scalars.parse_datetime)
proposal_code_scalar = ScalarType("ProposalCode")
proposal_code_scalar.set_serializer(scalars.serialize_proposal_code)
proposal_code_scalar.set_value_parser(scalars.parse_proposal_code)
mutation = MutationType()
mutation.set_field("submitProposal", resolvers.resolve_submit_proposal)
subscription = SubscriptionType()
subscription.set_field("submissionProgress", resolvers.resolve_submission_progress)
subscription.set_source("submissionProgress", resolvers.submission_progress_generator)
schema = make_executable_schema(
from datetime import date
from ariadne import ScalarType
date_scalar = ScalarType("Date")
@date_scalar.serializer
def serialize_date(value: str):
return date.fromisoformat(value).isoformat() if value != "" else None
import copy
from datetime import datetime
from ariadne import UnionType, ScalarType, InterfaceType, ObjectType
from web.data import ingredients, suppliers, products
product_interface = InterfaceType('ProductInterface')
product_type = UnionType('Product')
ingredient_type = ObjectType('Ingredient')
supplier_type = ObjectType('Supplier')
datetime_scalar = ScalarType('Datetime')
@datetime_scalar.serializer
def serialize_datetime_scalar(date):
return date.isoformat()
@datetime_scalar.value_parser
def parse_datetime_scalar(date):
return datetime.fromisoformat(date)
@product_type.type_resolver
def resolve_product_type(obj, *_):
if 'hasFilling' in obj:
return 'Cake'
return 'Beverage'
# pylint: disable=import-error
import json
from ariadne import ScalarType
JSON_STRING_SCALAR = ScalarType('JSONString')
@JSON_STRING_SCALAR.serializer
def serialize_jsonstring(value):
return json.dumps(value)
@JSON_STRING_SCALAR.value_parser
def parse_jsonstring_value(value):
return json.loads(value)
@JSON_STRING_SCALAR.literal_parser
def parse_jsonstring_literal(ast):
value = str(ast.value)
return json.loads(value)