text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_grant(self, grant):
""" Adds a Grant that the provider should support. :param grant: An instance of a class that extends :class:`oauth2.grant.GrantHandlerFactory` :type grant: oauth2.grant.GrantHandlerFactory """ |
if hasattr(grant, "expires_in"):
self.token_generator.expires_in[grant.grant_type] = grant.expires_in
if hasattr(grant, "refresh_expires_in"):
self.token_generator.refresh_expires_in = grant.refresh_expires_in
self.grant_types.append(grant) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def dispatch(self, request, environ):
""" Checks which Grant supports the current request and dispatches to it. :param request: The incoming request. :type request: :class:`oauth2.web.Request` :param environ: Dict containing variables of the environment. :type environ: dict :return: An instance of ``oauth2.web.Response``. """ |
try:
grant_type = self._determine_grant_type(request)
response = self.response_class()
grant_type.read_validate_params(request)
return grant_type.process(request, response, environ)
except OAuthInvalidNoRedirectError:
response = self.response_class()
response.add_header("Content-Type", "application/json")
response.status_code = 400
response.body = json.dumps({
"error": "invalid_redirect_uri",
"error_description": "Invalid redirect URI"
})
return response
except OAuthInvalidError as err:
response = self.response_class()
return grant_type.handle_error(error=err, response=response)
except UnsupportedGrantError:
response = self.response_class()
response.add_header("Content-Type", "application/json")
response.status_code = 400
response.body = json.dumps({
"error": "unsupported_response_type",
"error_description": "Grant not supported"
})
return response
except:
app_log.error("Uncaught Exception", exc_info=True)
response = self.response_class()
return grant_type.handle_error(
error=OAuthInvalidError(error="server_error",
explanation="Internal server error"),
response=response) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def enable_unique_tokens(self):
""" Enable the use of unique access tokens on all grant types that support this option. """ |
for grant_type in self.grant_types:
if hasattr(grant_type, "unique_token"):
grant_type.unique_token = True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def header(self, name, default=None):
""" Returns the value of the HTTP header identified by `name`. """ |
wsgi_header = "HTTP_{0}".format(name.upper())
try:
return self.env_raw[wsgi_header]
except KeyError:
return default |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def http_basic_auth(request):
""" Extracts the credentials of a client using HTTP Basic Auth. Expects the ``client_id`` to be the username and the ``client_secret`` to be the password part of the Authorization header. :param request: The incoming request :type request: oauth2.web.Request :return: A tuple in the format of (<CLIENT ID>, <CLIENT SECRET>)` :rtype: tuple """ |
auth_header = request.header("authorization")
if auth_header is None:
raise OAuthInvalidError(error="invalid_request",
explanation="Authorization header is missing")
auth_parts = auth_header.strip().encode("latin1").split(None)
if auth_parts[0].strip().lower() != b'basic':
raise OAuthInvalidError(
error="invalid_request",
explanation="Provider supports basic authentication only")
client_id, client_secret = b64decode(auth_parts[1]).split(b':', 1)
return client_id.decode("latin1"), client_secret.decode("latin1") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def by_identifier(self, request):
""" Authenticates a client by its identifier. :param request: The incoming request :type request: oauth2.web.Request :return: The identified client :rtype: oauth2.datatype.Client :raises: :class OAuthInvalidNoRedirectError: """ |
client_id = request.get_param("client_id")
if client_id is None:
raise OAuthInvalidNoRedirectError(error="missing_client_id")
try:
client = self.client_store.fetch_by_client_id(client_id)
except ClientNotFoundError:
raise OAuthInvalidNoRedirectError(error="unknown_client")
redirect_uri = request.get_param("redirect_uri")
if redirect_uri is not None:
try:
client.redirect_uri = redirect_uri
except RedirectUriUnknown:
raise OAuthInvalidNoRedirectError(
error="invalid_redirect_uri")
return client |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def expires_in(self):
""" Returns the time until the token expires. :return: The remaining time until expiration in seconds or 0 if the token has expired. """ |
time_left = self.expires_at - int(time.time())
if time_left > 0:
return time_left
return 0 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute(self, query, *params):
""" Executes a query and returns the identifier of the modified row. :param query: The query to be executed as a `str`. :param params: A `tuple` of parameters that will be replaced for placeholders in the query. :return: A `long` identifying the last altered row. """ |
cursor = self.connection.cursor()
try:
cursor.execute(query, params)
self.connection.commit()
return cursor.lastrowid
finally:
cursor.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetchone(self, query, *args):
""" Returns the first result of the given query. :param query: The query to be executed as a `str`. :param params: A `tuple` of parameters that will be replaced for placeholders in the query. :return: The retrieved row with each field being one element in a `tuple`. """ |
cursor = self.connection.cursor()
try:
cursor.execute(query, args)
return cursor.fetchone()
finally:
cursor.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetchall(self, query, *args):
""" Returns all results of the given query. :param query: The query to be executed as a `str`. :param params: A `tuple` of parameters that will be replaced for placeholders in the query. :return: A `list` of `tuple`s with each field being one element in the `tuple`. """ |
cursor = self.connection.cursor()
try:
cursor.execute(query, args)
return cursor.fetchall()
finally:
cursor.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch_by_refresh_token(self, refresh_token):
""" Retrieves an access token by its refresh token. :param refresh_token: The refresh token of an access token as a `str`. :return: An instance of :class:`oauth2.datatype.AccessToken`. :raises: :class:`oauth2.error.AccessTokenNotFound` if not access token could be retrieved. """ |
row = self.fetchone(self.fetch_by_refresh_token_query, refresh_token)
if row is None:
raise AccessTokenNotFound
scopes = self._fetch_scopes(access_token_id=row[0])
data = self._fetch_data(access_token_id=row[0])
return self._row_to_token(data=data, scopes=scopes, row=row) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch_existing_token_of_user(self, client_id, grant_type, user_id):
""" Retrieve an access token issued to a client and user for a specific grant. :param client_id: The identifier of a client as a `str`. :param grant_type: The type of grant. :param user_id: The identifier of the user the access token has been issued to. :return: An instance of :class:`oauth2.datatype.AccessToken`. :raises: :class:`oauth2.error.AccessTokenNotFound` if not access token could be retrieved. """ |
token_data = self.fetchone(self.fetch_existing_token_of_user_query,
client_id, grant_type, user_id)
if token_data is None:
raise AccessTokenNotFound
scopes = self._fetch_scopes(access_token_id=token_data[0])
data = self._fetch_data(access_token_id=token_data[0])
return self._row_to_token(data=data, scopes=scopes, row=token_data) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_token(self, access_token):
""" Creates a new entry for an access token in the database. :param access_token: An instance of :class:`oauth2.datatype.AccessToken`. :return: `True`. """ |
access_token_id = self.execute(self.create_access_token_query,
access_token.client_id,
access_token.grant_type,
access_token.token,
access_token.expires_at,
access_token.refresh_token,
access_token.refresh_expires_at,
access_token.user_id)
for key, value in list(access_token.data.items()):
self.execute(self.create_data_query, key, value,
access_token_id)
for scope in access_token.scopes:
self.execute(self.create_scope_query, scope, access_token_id)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch_by_code(self, code):
""" Retrieves an auth code by its code. :param code: The code of an auth code. :return: An instance of :class:`oauth2.datatype.AuthorizationCode`. :raises: :class:`oauth2.error.AuthCodeNotFound` if no auth code could be retrieved. """ |
auth_code_data = self.fetchone(self.fetch_code_query, code)
if auth_code_data is None:
raise AuthCodeNotFound
data = dict()
data_result = self.fetchall(self.fetch_data_query, auth_code_data[0])
if data_result is not None:
for dataset in data_result:
data[dataset[0]] = dataset[1]
scopes = []
scope_result = self.fetchall(self.fetch_scopes_query,
auth_code_data[0])
if scope_result is not None:
for scope_set in scope_result:
scopes.append(scope_set[0])
return AuthorizationCode(client_id=auth_code_data[1],
code=auth_code_data[2],
expires_at=auth_code_data[3],
redirect_uri=auth_code_data[4],
scopes=scopes, data=data,
user_id=auth_code_data[5]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_code(self, authorization_code):
""" Creates a new entry of an auth code in the database. :param authorization_code: An instance of :class:`oauth2.datatype.AuthorizationCode`. :return: `True` if everything went fine. """ |
auth_code_id = self.execute(self.create_auth_code_query,
authorization_code.client_id,
authorization_code.code,
authorization_code.expires_at,
authorization_code.redirect_uri,
authorization_code.user_id)
for key, value in list(authorization_code.data.items()):
self.execute(self.create_data_query, key, value, auth_code_id)
for scope in authorization_code.scopes:
self.execute(self.create_scope_query, scope, auth_code_id)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch_by_client_id(self, client_id):
""" Retrieves a client by its identifier. :param client_id: The identifier of a client. :return: An instance of :class:`oauth2.datatype.Client`. :raises: :class:`oauth2.error.ClientError` if no client could be retrieved. """ |
grants = None
redirect_uris = None
response_types = None
client_data = self.fetchone(self.fetch_client_query, client_id)
if client_data is None:
raise ClientNotFoundError
grant_data = self.fetchall(self.fetch_grants_query, client_data[0])
if grant_data:
grants = []
for grant in grant_data:
grants.append(grant[0])
redirect_uris_data = self.fetchall(self.fetch_redirect_uris_query,
client_data[0])
if redirect_uris_data:
redirect_uris = []
for redirect_uri in redirect_uris_data:
redirect_uris.append(redirect_uri[0])
response_types_data = self.fetchall(self.fetch_response_types_query,
client_data[0])
if response_types_data:
response_types = []
for response_type in response_types_data:
response_types.append(response_type[0])
return Client(identifier=client_data[1], secret=client_data[2],
authorized_grants=grants,
authorized_response_types=response_types,
redirect_uris=redirect_uris) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch_by_code(self, code):
""" Returns data belonging to an authorization code from memcache or ``None`` if no data was found. See :class:`oauth2.store.AuthCodeStore`. """ |
code_data = self.mc.get(self._generate_cache_key(code))
if code_data is None:
raise AuthCodeNotFound
return AuthorizationCode(**code_data) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_code(self, authorization_code):
""" Stores the data belonging to an authorization code token in memcache. See :class:`oauth2.store.AuthCodeStore`. """ |
key = self._generate_cache_key(authorization_code.code)
self.mc.set(key, {"client_id": authorization_code.client_id,
"code": authorization_code.code,
"expires_at": authorization_code.expires_at,
"redirect_uri": authorization_code.redirect_uri,
"scopes": authorization_code.scopes,
"data": authorization_code.data,
"user_id": authorization_code.user_id}) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_token(self, access_token):
""" Stores the access token and additional data in memcache. See :class:`oauth2.store.AccessTokenStore`. """ |
key = self._generate_cache_key(access_token.token)
self.mc.set(key, access_token.__dict__)
unique_token_key = self._unique_token_key(access_token.client_id,
access_token.grant_type,
access_token.user_id)
self.mc.set(self._generate_cache_key(unique_token_key),
access_token.__dict__)
if access_token.refresh_token is not None:
rft_key = self._generate_cache_key(access_token.refresh_token)
self.mc.set(rft_key, access_token.__dict__) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def encode_scopes(scopes, use_quote=False):
""" Creates a string out of a list of scopes. :param scopes: A list of scopes :param use_quote: Boolean flag indicating whether the string should be quoted :return: Scopes as a string """ |
scopes_as_string = Scope.separator.join(scopes)
if use_quote:
return quote(scopes_as_string)
return scopes_as_string |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def json_error_response(error, response, status_code=400):
""" Formats an error as a response containing a JSON body. """ |
msg = {"error": error.error, "error_description": error.explanation}
response.status_code = status_code
response.add_header("Content-Type", "application/json")
response.body = json.dumps(msg)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def json_success_response(data, response):
""" Formats the response of a successful token request as JSON. Also adds default headers and status code. """ |
response.body = json.dumps(data)
response.status_code = 200
response.add_header("Content-Type", "application/json")
response.add_header("Cache-Control", "no-store")
response.add_header("Pragma", "no-cache") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compare(self, previous_scopes):
""" Compares the scopes read from request with previously issued scopes. :param previous_scopes: A list of scopes. :return: ``True`` """ |
for scope in self.scopes:
if scope not in previous_scopes:
raise OAuthInvalidError(
error="invalid_scope",
explanation="Invalid scope parameter in request")
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse(self, request, source):
""" Parses scope value in given request. Expects the value of the "scope" parameter in request to be a string where each requested scope is separated by a white space:: # One scope requested "profile_read" # Multiple scopes "profile_read profile_write" :param request: An instance of :class:`oauth2.web.Request`. :param source: Where to read the scope from. Pass "body" in case of a application/x-www-form-urlencoded body and "query" in case the scope is supplied as a query parameter in the URL of a request. """ |
if source == "body":
req_scope = request.post_param("scope")
elif source == "query":
req_scope = request.get_param("scope")
else:
raise ValueError("Unknown scope source '" + source + "'")
if req_scope is None:
if self.default is not None:
self.scopes = [self.default]
self.send_back = True
return
elif len(self.available_scopes) != 0:
raise OAuthInvalidError(
error="invalid_scope",
explanation="Missing scope parameter in request")
else:
return
req_scopes = req_scope.split(self.separator)
self.scopes = [scope for scope in req_scopes
if scope in self.available_scopes]
if len(self.scopes) == 0 and self.default is not None:
self.scopes = [self.default]
self.send_back = True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_validate_params(self, request):
""" Reads and validates data in an incoming request as required by the Authorization Request of the Authorization Code Grant and the Implicit Grant. """ |
self.client = self.client_authenticator.by_identifier(request)
response_type = request.get_param("response_type")
if self.client.response_type_supported(response_type) is False:
raise OAuthInvalidError(error="unauthorized_client")
self.state = request.get_param("state")
self.scope_handler.parse(request, "query")
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def authorize(self, request, response, environ, scopes):
""" Controls all steps to authorize a request by a user. :param request: The incoming :class:`oauth2.web.Request` :param response: The :class:`oauth2.web.Response` that will be returned eventually :param environ: The environment variables of this request :param scopes: The scopes requested by an application :return: A tuple containing (`dict`, user_id) or the response. """ |
if self.site_adapter.user_has_denied_access(request) is True:
raise OAuthInvalidError(error="access_denied",
explanation="Authorization denied by user")
try:
result = self.site_adapter.authenticate(request, environ, scopes,
self.client)
return self.sanitize_return_value(result)
except UserNotAuthenticated:
return self.site_adapter.render_auth_page(request, response,
environ, scopes,
self.client) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process(self, request, response, environ):
""" Generates a new authorization token. A form to authorize the access of the application can be displayed with the help of `oauth2.web.SiteAdapter`. """ |
data = self.authorize(request, response, environ,
self.scope_handler.scopes)
if isinstance(data, Response):
return data
code = self.token_generator.generate()
expires = int(time.time()) + self.token_expiration
auth_code = AuthorizationCode(client_id=self.client.identifier,
code=code, expires_at=expires,
redirect_uri=self.client.redirect_uri,
scopes=self.scope_handler.scopes,
data=data[0], user_id=data[1])
self.auth_code_store.save_code(auth_code)
response.add_header("Location", self._generate_location(code))
response.body = ""
response.status_code = 302
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def handle_error(self, error, response):
""" Redirects the client in case an error in the auth process occurred. """ |
query_params = {"error": error.error}
query = urlencode(query_params)
location = "%s?%s" % (self.client.redirect_uri, query)
response.status_code = 302
response.body = ""
response.add_header("Location", location)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process(self, request, response, environ):
""" Generates a new access token and returns it. Returns the access token and the type of the token as JSON. Calls `oauth2.store.AccessTokenStore` to persist the token. """ |
token_data = self.create_token(
client_id=self.client.identifier,
data=self.data,
grant_type=AuthorizationCodeGrant.grant_type,
scopes=self.scopes,
user_id=self.user_id)
self.auth_code_store.delete_code(self.code)
if self.scopes:
token_data["scope"] = encode_scopes(self.scopes)
json_success_response(data=token_data, response=response)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process(self, request, response, environ):
""" Takes the incoming request, asks the concrete SiteAdapter to validate it and issues a new access token that is returned to the client on successful validation. """ |
try:
data = self.site_adapter.authenticate(request, environ,
self.scope_handler.scopes,
self.client)
data = AuthorizeMixin.sanitize_return_value(data)
except UserNotAuthenticated:
raise OAuthInvalidError(error="invalid_client",
explanation=self.OWNER_NOT_AUTHENTICATED)
if isinstance(data, Response):
return data
token_data = self.create_token(
client_id=self.client.identifier,
data=data[0],
grant_type=ResourceOwnerGrant.grant_type,
scopes=self.scope_handler.scopes,
user_id=data[1])
if self.scope_handler.send_back:
token_data["scope"] = encode_scopes(self.scope_handler.scopes)
json_success_response(data=token_data, response=response)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_validate_params(self, request):
""" Checks if all incoming parameters meet the expected values. """ |
self.client = self.client_authenticator.by_identifier_secret(request)
self.password = request.post_param("password")
self.username = request.post_param("username")
self.scope_handler.parse(request=request, source="body")
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_validate_params(self, request):
""" Validate the incoming request. :param request: The incoming :class:`oauth2.web.Request`. :return: Returns ``True`` if data is valid. :raises: :class:`oauth2.error.OAuthInvalidError` """ |
self.refresh_token = request.post_param("refresh_token")
if self.refresh_token is None:
raise OAuthInvalidError(
error="invalid_request",
explanation="Missing refresh_token in request body")
self.client = self.client_authenticator.by_identifier_secret(request)
try:
access_token = self.access_token_store.fetch_by_refresh_token(
self.refresh_token
)
except AccessTokenNotFound:
raise OAuthInvalidError(error="invalid_request",
explanation="Invalid refresh token")
refresh_token_expires_at = access_token.refresh_expires_at
self.refresh_grant_type = access_token.grant_type
if refresh_token_expires_at != 0 and \
refresh_token_expires_at < int(time.time()):
raise OAuthInvalidError(error="invalid_request",
explanation="Invalid refresh token")
self.data = access_token.data
self.user_id = access_token.user_id
self.scope_handler.parse(request, "body")
self.scope_handler.compare(access_token.scopes)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def value_for_keypath(obj, path):
"""Get value from walking key path with start object obj. """ |
val = obj
for part in path.split('.'):
match = re.match(list_index_re, part)
if match is not None:
val = _extract(val, match.group(1))
if not isinstance(val, list) and not isinstance(val, tuple):
raise TypeError('expected list/tuple')
index = int(match.group(2))
val = val[index]
else:
val = _extract(val, part)
if val is None:
return None
return val |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_value_for_keypath(obj, path, new_value, preserve_child = False):
"""Set attribute value new_value at key path of start object obj. """ |
parts = path.split('.')
last_part = len(parts) - 1
dst = obj
for i, part in enumerate(parts):
match = re.match(list_index_re, part)
if match is not None:
dst = _extract(dst, match.group(1))
if not isinstance(dst, list) and not isinstance(dst, tuple):
raise TypeError('expected list/tuple')
index = int(match.group(2))
if i == last_part:
dst[index] = new_value
else:
dst = dst[index]
else:
if i != last_part:
dst = _extract(dst, part)
else:
if isinstance(dst, dict):
dst[part] = new_value
else:
if not preserve_child:
setattr(dst, part, new_value)
else:
try:
v = getattr(dst, part)
except AttributeError:
setattr(dst, part, new_value) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def view_for_image_named(image_name):
"""Create an ImageView for the given image.""" |
image = resource.get_image(image_name)
if not image:
return None
return ImageView(pygame.Rect(0, 0, 0, 0), image) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fill_gradient(surface, color, gradient, rect=None, vertical=True, forward=True):
"""Fill a surface with a linear gradient pattern. color starting color gradient final color rect area to fill; default is surface's rect vertical True=vertical; False=horizontal forward True=forward; False=reverse See http://www.pygame.org/wiki/GradientCode """ |
if rect is None:
rect = surface.get_rect()
x1, x2 = rect.left, rect.right
y1, y2 = rect.top, rect.bottom
if vertical:
h = y2 - y1
else:
h = x2 - x1
assert h > 0
if forward:
a, b = color, gradient
else:
b, a = color, gradient
rate = (float(b[0] - a[0]) / h,
float(b[1] - a[1]) / h,
float(b[2] - a[2]) / h)
fn_line = pygame.draw.line
if vertical:
for line in range(y1, y2):
color = (min(max(a[0] + (rate[0] * (line - y1)), 0), 255),
min(max(a[1] + (rate[1] * (line - y1)), 0), 255),
min(max(a[2] + (rate[2] * (line - y1)), 0), 255))
fn_line(surface, color, (x1, line), (x2, line))
else:
for col in range(x1, x2):
color = (min(max(a[0] + (rate[0] * (col - x1)), 0), 255),
min(max(a[1] + (rate[1] * (col - x1)), 0), 255),
min(max(a[2] + (rate[2] * (col - x1)), 0), 255))
fn_line(surface, color, (col, y1), (col, y2)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def shrink_wrap(self):
"""Tightly bound the current text respecting current padding.""" |
self.frame.size = (self.text_size[0] + self.padding[0] * 2,
self.text_size[1] + self.padding[1] * 2) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def layout(self):
"""Call to have the view layout itself. Subclasses should invoke this after laying out child views and/or updating its own frame. """ |
if self.shadowed:
shadow_size = theme.current.shadow_size
shadowed_frame_size = (self.frame.w + shadow_size,
self.frame.h + shadow_size)
self.surface = pygame.Surface(
shadowed_frame_size, pygame.SRCALPHA, 32)
shadow_image = resource.get_image('shadow')
self.shadow_image = resource.scale_image(shadow_image,
shadowed_frame_size)
else:
self.surface = pygame.Surface(self.frame.size, pygame.SRCALPHA, 32)
self.shadow_image = None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stylize(self):
"""Apply theme style attributes to this instance and its children. This also causes a relayout to occur so that any changes in padding or other stylistic attributes may be handled. """ |
# do children first in case parent needs to override their style
for child in self.children:
child.stylize()
style = theme.current.get_dict(self)
preserve_child = False
try:
preserve_child = getattr(theme.current, 'preserve_child')
except:
preserve_child = False
for key, val in style.iteritems():
kvc.set_value_for_keypath(self, key, val, preserve_child)
self.layout() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def draw(self):
"""Do not call directly.""" |
if self.hidden:
return False
if self.background_color is not None:
render.fillrect(self.surface, self.background_color,
rect=pygame.Rect((0, 0), self.frame.size))
for child in self.children:
if not child.hidden:
child.draw()
topleft = child.frame.topleft
if child.shadowed:
shadow_size = theme.current.shadow_size
shadow_topleft = (topleft[0] - shadow_size // 2,
topleft[1] - shadow_size // 2)
self.surface.blit(child.shadow_image, shadow_topleft)
self.surface.blit(child.surface, topleft)
if child.border_color and child.border_widths is not None:
if (type(child.border_widths) is int and
child.border_widths > 0):
pygame.draw.rect(self.surface, child.border_color,
child.frame, child.border_widths)
else:
tw, lw, bw, rw = child.get_border_widths()
tl = (child.frame.left, child.frame.top)
tr = (child.frame.right - 1, child.frame.top)
bl = (child.frame.left, child.frame.bottom - 1)
br = (child.frame.right - 1, child.frame.bottom - 1)
if tw > 0:
pygame.draw.line(self.surface, child.border_color,
tl, tr, tw)
if lw > 0:
pygame.draw.line(self.surface, child.border_color,
tl, bl, lw)
if bw > 0:
pygame.draw.line(self.surface, child.border_color,
bl, br, bw)
if rw > 0:
pygame.draw.line(self.surface, child.border_color,
tr, br, rw)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_border_widths(self):
"""Return border width for each side top, left, bottom, right.""" |
if type(self.border_widths) is int: # uniform size
return [self.border_widths] * 4
return self.border_widths |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def use_theme(theme):
"""Make the given theme current. There are two included themes: light_theme, dark_theme. """ |
global current
current = theme
import scene
if scene.current is not None:
scene.current.stylize() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set(self, class_name, state, key, value):
"""Set a single style value for a view class and state. class_name The name of the class to be styled; do not include the package name; e.g. 'Button'. state The name of the state to be stylized. One of the following: 'normal', 'focused', 'selected', 'disabled' is common. key The style attribute name; e.g. 'background_color'. value The value of the style attribute; colors are either a 3-tuple for RGB, a 4-tuple for RGBA, or a pair thereof for a linear gradient. """ |
self._styles.setdefault(class_name, {}).setdefault(state, {})
self._styles[class_name][state][key] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_dict_for_class(self, class_name, state=None, base_name='View'):
"""The style dict for a given class and state. This collects the style attributes from parent classes and the class of the given object and gives precedence to values thereof to the children. The state attribute of the view instance is taken as the current state if state is None. If the state is not 'normal' then the style definitions for the 'normal' state are mixed-in from the given state style definitions, giving precedence to the non-'normal' style definitions. """ |
classes = []
klass = class_name
while True:
classes.append(klass)
if klass.__name__ == base_name:
break
klass = klass.__bases__[0]
if state is None:
state = 'normal'
style = {}
for klass in classes:
class_name = klass.__name__
try:
state_styles = self._styles[class_name][state]
except KeyError:
state_styles = {}
if state != 'normal':
try:
normal_styles = self._styles[class_name]['normal']
except KeyError:
normal_styles = {}
state_styles = dict(chain(normal_styles.iteritems(),
state_styles.iteritems()))
style = dict(chain(state_styles.iteritems(),
style.iteritems()))
return style |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_dict(self, obj, state=None, base_name='View'):
"""The style dict for a view instance. """ |
return self.get_dict_for_class(class_name=obj.__class__,
state=obj.state,
base_name=base_name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_value(self, class_name, attr, default_value=None, state='normal', base_name='View'):
"""Get a single style attribute value for the given class. """ |
styles = self.get_dict_for_class(class_name, state, base_name)
try:
return styles[attr]
except KeyError:
return default_value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def instantiate_object_id_field(object_id_class_or_tuple=models.TextField):
""" Instantiates and returns a model field for FieldHistory.object_id. object_id_class_or_tuple may be either a Django model field class or a tuple of (model_field, kwargs), where kwargs is a dict passed to model_field's constructor. """ |
if isinstance(object_id_class_or_tuple, (list, tuple)):
object_id_class, object_id_kwargs = object_id_class_or_tuple
else:
object_id_class = object_id_class_or_tuple
object_id_kwargs = {}
if not issubclass(object_id_class, models.fields.Field):
raise TypeError('settings.%s must be a Django model field or (field, kwargs) tuple' % OBJECT_ID_TYPE_SETTING)
if not isinstance(object_id_kwargs, dict):
raise TypeError('settings.%s kwargs must be a dict' % OBJECT_ID_TYPE_SETTING)
return object_id_class(db_index=True, **object_id_kwargs) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def has_expired(self, lifetime, now=None):
"""Report if the session key has expired. :param lifetime: A :class:`datetime.timedelta` that specifies the maximum age this :class:`SessionID` should be checked against. :param now: If specified, use this :class:`~datetime.datetime` instance instead of :meth:`~datetime.datetime.utcnow()` as the current time. """ |
now = now or datetime.utcnow()
return now > self.created + lifetime |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def unserialize(cls, string):
"""Unserializes from a string. :param string: A string created by :meth:`serialize`. """ |
id_s, created_s = string.split('_')
return cls(int(id_s, 16),
datetime.utcfromtimestamp(int(created_s, 16))) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def destroy(self):
"""Destroys a session completely, by deleting all keys and removing it from the internal store immediately. This allows removing a session for security reasons, e.g. a login stored in a session will cease to exist if the session is destroyed. """ |
for k in list(self.keys()):
del self[k]
if getattr(self, 'sid_s', None):
current_app.kvsession_store.delete(self.sid_s)
self.sid_s = None
self.modified = False
self.new = False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def regenerate(self):
"""Generate a new session id for this session. To avoid vulnerabilities through `session fixation attacks <http://en.wikipedia.org/wiki/Session_fixation>`_, this function can be called after an action like a login has taken place. The session will be copied over to a new session id and the old one removed. """ |
self.modified = True
if getattr(self, 'sid_s', None):
# delete old session
current_app.kvsession_store.delete(self.sid_s)
# remove sid_s, set modified
self.sid_s = None
self.modified = True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def cleanup_sessions(self, app=None):
"""Removes all expired session from the store. Periodically, this function can be called to remove sessions from the backend store that have expired, as they are not removed automatically unless the backend supports time-to-live and has been configured appropriately (see :class:`~simplekv.TimeToLiveMixin`). This function retrieves all session keys, checks they are older than :attr:`flask.Flask.permanent_session_lifetime` and if so, removes them. Note that no distinction is made between non-permanent and permanent sessions. :param app: The app whose sessions should be cleaned up. If ``None``, uses :py:data:`~flask.current_app`.""" |
if not app:
app = current_app
for key in app.kvsession_store.keys():
m = self.key_regex.match(key)
now = datetime.utcnow()
if m:
# read id
sid = SessionID.unserialize(key)
# remove if expired
if sid.has_expired(app.permanent_session_lifetime, now):
app.kvsession_store.delete(key) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def init_app(self, app, session_kvstore=None):
"""Initialize application and KVSession. This will replace the session management of the application with Flask-KVSession's. :param app: The :class:`~flask.Flask` app to be initialized.""" |
app.config.setdefault('SESSION_KEY_BITS', 64)
app.config.setdefault('SESSION_RANDOM_SOURCE', SystemRandom())
if not session_kvstore and not self.default_kvstore:
raise ValueError('Must supply session_kvstore either on '
'construction or init_app().')
# set store on app, either use default
# or supplied argument
app.kvsession_store = session_kvstore or self.default_kvstore
app.session_interface = KVSessionInterface() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def transfer_config_dict(soap_object, data_dict):
""" This is a utility function used in the certification modules to transfer the data dicts above to SOAP objects. This avoids repetition and allows us to store all of our variable configuration here rather than in each certification script. """ |
for key, val in data_dict.items():
# Transfer each key to the matching attribute ont he SOAP object.
setattr(soap_object, key, val) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_package(self, package_item):
""" Adds a package to the ship request. @type package_item: WSDL object, type of RequestedPackageLineItem WSDL object. @keyword package_item: A RequestedPackageLineItem, created by calling create_wsdl_object_of_type('RequestedPackageLineItem') on this ShipmentRequest object. See examples/create_shipment.py for more details. """ |
self.RequestedShipment.RequestedPackageLineItems.append(package_item)
package_weight = package_item.Weight.Value
self.RequestedShipment.TotalWeight.Value += package_weight
self.RequestedShipment.PackageCount += 1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _prepare_wsdl_objects(self):
""" Preps the WSDL data structures for the user. """ |
self.DeletionControlType = self.client.factory.create('DeletionControlType')
self.TrackingId = self.client.factory.create('TrackingId')
self.TrackingId.TrackingIdType = self.client.factory.create('TrackingIdType') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __set_web_authentication_detail(self):
""" Sets up the WebAuthenticationDetail node. This is required for all requests. """ |
# Start of the authentication stuff.
web_authentication_credential = self.client.factory.create('WebAuthenticationCredential')
web_authentication_credential.Key = self.config_obj.key
web_authentication_credential.Password = self.config_obj.password
# Encapsulates the auth credentials.
web_authentication_detail = self.client.factory.create('WebAuthenticationDetail')
web_authentication_detail.UserCredential = web_authentication_credential
# Set Default ParentCredential
if hasattr(web_authentication_detail, 'ParentCredential'):
web_authentication_detail.ParentCredential = web_authentication_credential
self.WebAuthenticationDetail = web_authentication_detail |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __set_client_detail(self, *args, **kwargs):
""" Sets up the ClientDetail node, which is required for all shipping related requests. """ |
client_detail = self.client.factory.create('ClientDetail')
client_detail.AccountNumber = self.config_obj.account_number
client_detail.MeterNumber = self.config_obj.meter_number
client_detail.IntegratorId = self.config_obj.integrator_id
if hasattr(client_detail, 'Region'):
client_detail.Region = self.config_obj.express_region_code
client_language_code = kwargs.get('client_language_code', None)
client_locale_code = kwargs.get('client_locale_code', None)
if hasattr(client_detail, 'Localization') and (client_language_code or client_locale_code):
localization = self.client.factory.create('Localization')
if client_language_code:
localization.LanguageCode = client_language_code
if client_locale_code:
localization.LocaleCode = client_locale_code
client_detail.Localization = localization
self.ClientDetail = client_detail |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __set_transaction_detail(self, *args, **kwargs):
""" Checks kwargs for 'customer_transaction_id' and sets it if present. """ |
customer_transaction_id = kwargs.get('customer_transaction_id', None)
if customer_transaction_id:
transaction_detail = self.client.factory.create('TransactionDetail')
transaction_detail.CustomerTransactionId = customer_transaction_id
self.logger.debug(transaction_detail)
self.TransactionDetail = transaction_detail |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __set_version_id(self):
""" Pulles the versioning info for the request from the child request. """ |
version_id = self.client.factory.create('VersionId')
version_id.ServiceId = self._version_info['service_id']
version_id.Major = self._version_info['major']
version_id.Intermediate = self._version_info['intermediate']
version_id.Minor = self._version_info['minor']
self.logger.debug(version_id)
self.VersionId = version_id |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __check_response_for_fedex_error(self):
""" This checks the response for general Fedex errors that aren't related to any one WSDL. """ |
if self.response.HighestSeverity == "FAILURE":
for notification in self.response.Notifications:
if notification.Severity == "FAILURE":
raise FedexFailure(notification.Code,
notification.Message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _check_response_for_request_errors(self):
""" Override this in each service module to check for errors that are specific to that module. For example, invalid tracking numbers in a Tracking request. """ |
if self.response.HighestSeverity == "ERROR":
for notification in self.response.Notifications:
if notification.Severity == "ERROR":
raise FedexError(notification.Code,
notification.Message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send_request(self, send_function=None):
""" Sends the assembled request on the child object. @type send_function: function reference @keyword send_function: A function reference (passed without the parenthesis) to a function that will send the request. This allows for overriding the default function in cases such as validation requests. """ |
# Send the request and get the response back.
try:
# If the user has overridden the send function, use theirs
# instead of the default.
if send_function:
# Follow the overridden function.
self.response = send_function()
else:
# Default scenario, business as usual.
self.response = self._assemble_and_send_request()
except suds.WebFault as fault:
# When this happens, throw an informative message reminding the
# user to check all required variables, making sure they are
# populated and valid
raise SchemaValidationError(fault.fault)
# Check the response for general Fedex errors/failures that aren't
# specific to any given WSDL/request.
self.__check_response_for_fedex_error()
# Check the response for errors specific to the particular request.
# This method can be overridden by a method on the child class object.
self._check_response_for_request_errors()
# Check the response for errors specific to the particular request.
# This method can be overridden by a method on the child class object.
self._check_response_for_request_warnings()
# Debug output. (See Request and Response output)
self.logger.debug("== FEDEX QUERY RESULT ==")
self.logger.debug(self.response) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _prepare_wsdl_objects(self):
""" This sets the package identifier information. This may be a tracking number or a few different things as per the Fedex spec. """ |
self.SelectionDetails = self.client.factory.create('TrackSelectionDetail')
# Default to Fedex
self.SelectionDetails.CarrierCode = 'FDXE'
track_package_id = self.client.factory.create('TrackPackageIdentifier')
# Default to tracking number.
track_package_id.Type = 'TRACKING_NUMBER_OR_DOORTAG'
self.SelectionDetails.PackageIdentifier = track_package_id |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def print_label(self, package_num=None):
""" Prints all of a shipment's labels, or optionally just one. @type package_num: L{int} @param package_num: 0-based index of the package to print. This is only useful for shipments with more than one package. """ |
if package_num:
packages = [
self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails[package_num]
]
else:
packages = self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails
for package in packages:
label_binary = binascii.a2b_base64(package.Label.Parts[0].Image)
self._print_base64(label_binary) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _print_base64(self, base64_data):
""" Pipe the binary directly to the label printer. Works under Linux without requiring PySerial. This is not typically something you should call directly, unless you have special needs. @type base64_data: L{str} @param base64_data: The base64 encoded string for the label to print. """ |
label_file = open(self.device, "w")
label_file.write(base64_data)
label_file.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def guess_tags(filename):
""" Function to get potential tags for files using the file names. :param filename: This field is the name of file. """ |
tags = []
stripped_filename = strip_zip_suffix(filename)
if stripped_filename.endswith('.vcf'):
tags.append('vcf')
if stripped_filename.endswith('.json'):
tags.append('json')
if stripped_filename.endswith('.csv'):
tags.append('csv')
return tags |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def characterize_local_files(filedir, max_bytes=MAX_FILE_DEFAULT):
""" Collate local file info as preperation for Open Humans upload. Note: Files with filesize > max_bytes are not included in returned info. :param filedir: This field is target directory to get files from. :param max_bytes: This field is the maximum file size to consider. Its default value is 128m. """ |
file_data = {}
logging.info('Characterizing files in {}'.format(filedir))
for filename in os.listdir(filedir):
filepath = os.path.join(filedir, filename)
file_stats = os.stat(filepath)
creation_date = arrow.get(file_stats.st_ctime).isoformat()
file_size = file_stats.st_size
if file_size <= max_bytes:
file_md5 = hashlib.md5()
with open(filepath, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
file_md5.update(chunk)
md5 = file_md5.hexdigest()
file_data[filename] = {
'tags': guess_tags(filename),
'description': '',
'md5': md5,
'creation_date': creation_date,
}
return file_data |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_metadata(target_dir, metadata):
""" Check that the files listed in metadata exactly match files in target dir. :param target_dir: This field is the target directory from which to match metadata :param metadata: This field contains the metadata to be matched. """ |
if not os.path.isdir(target_dir):
print("Error: " + target_dir + " is not a directory")
return False
file_list = os.listdir(target_dir)
for filename in file_list:
if filename not in metadata:
print("Error: " + filename + " present at" + target_dir +
" not found in metadata file")
return False
for filename in metadata:
if filename not in file_list:
print("Error: " + filename + " present in metadata file " +
" not found on disk at: " + target_dir)
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_metadata_csv_single_user(csv_in, header, tags_idx):
""" Return the metadata as requested for a single user. :param csv_in: This field is the csv file to return metadata from. :param header: This field contains the headers in the csv file :param tags_idx: This field contains the index of the tags in the csv file. """ |
metadata = {}
n_headers = len(header)
for index, row in enumerate(csv_in, 2):
if row[0] == "":
raise ValueError('Error: In row number ' + str(index) + ':' +
' "filename" must not be empty.')
if row[0] == 'None' and [x == 'NA' for x in row[1:]]:
break
if len(row) != n_headers:
raise ValueError('Error: In row number ' + str(index) + ':' +
' Number of columns (' + str(len(row)) +
') doesnt match Number of headings (' +
str(n_headers) + ')')
metadata[row[0]] = {
header[i]: row[i] for i in range(1, len(header)) if
i != tags_idx
}
metadata[row[0]]['tags'] = [t.strip() for t in
row[tags_idx].split(',') if
t.strip()]
return metadata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_metadata_csv(input_filepath):
""" Return dict of metadata. Format is either dict (filenames are keys) or dict-of-dicts (project member IDs as top level keys, then filenames as keys). :param input_filepath: This field is the filepath of the csv file. """ |
with open(input_filepath) as f:
csv_in = csv.reader(f)
header = next(csv_in)
if 'tags' in header:
tags_idx = header.index('tags')
else:
raise ValueError('"tags" is a compulsory column in metadata file.')
if header[0] == 'project_member_id':
if header[1] == 'filename':
metadata = load_metadata_csv_multi_user(csv_in, header,
tags_idx)
else:
raise ValueError('The second column must be "filename"')
elif header[0] == 'filename':
metadata = load_metadata_csv_single_user(csv_in, header, tags_idx)
else:
raise ValueError('Incorrect Formatting of metadata. The first' +
' column for single user upload should be' +
' "filename". For multiuser uploads the first ' +
'column should be "project member id" and the' +
' second column should be "filename"')
return metadata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_date(date, project_member_id, filename):
""" Check if date is in ISO 8601 format. :param date: This field is the date to be checked. :param project_member_id: This field is the project_member_id corresponding to the date provided. :param filename: This field is the filename corresponding to the date provided. """ |
try:
arrow.get(date)
except Exception:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_single_file_metadata_valid(file_metadata, project_member_id, filename):
""" Check if metadata fields like project member id, description, tags, md5 and creation date are valid for a single file. :param file_metadata: This field is metadata of file. :param project_member_id: This field is the project member id corresponding to the file metadata provided. :param filename: This field is the filename corresponding to the file metadata provided. """ |
if project_member_id is not None:
if not project_member_id.isdigit() or len(project_member_id) != 8:
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' project member id must be of 8 digits from 0 to 9')
if 'description' not in file_metadata:
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' "description" is a required field of the metadata')
if not isinstance(file_metadata['description'], str):
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' "description" must be a string')
if 'tags' not in file_metadata:
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' "tags" is a required field of the metadata')
if not isinstance(file_metadata['tags'], list):
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' "tags" must be an array of strings')
if 'creation_date' in file_metadata:
if not validate_date(file_metadata['creation_date'], project_member_id,
filename):
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' Dates must be in ISO 8601 format')
if 'md5' in file_metadata:
if not re.match(r'[a-f0-9]{32}$', file_metadata['md5'],
flags=re.IGNORECASE):
raise ValueError(
'Error: for project member id: ', project_member_id,
' and filename: ', filename,
' Invalid MD5 specified')
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def review_metadata_csv_single_user(filedir, metadata, csv_in, n_headers):
""" Check validity of metadata for single user. :param filedir: This field is the filepath of the directory whose csv has to be made. :param metadata: This field is the metadata generated from the load_metadata_csv function. :param csv_in: This field returns a reader object which iterates over the csv. :param n_headers: This field is the number of headers in the csv. """ |
try:
if not validate_metadata(filedir, metadata):
return False
for filename, file_metadata in metadata.items():
is_single_file_metadata_valid(file_metadata, None, filename)
except ValueError as e:
print_error(e)
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_subfolders(filedir, metadata):
""" Check that all folders in the given directory have a corresponding entry in the metadata file, and vice versa. :param filedir: This field is the target directory from which to match metadata :param metadata: This field contains the metadata to be matched. """ |
if not os.path.isdir(filedir):
print("Error: " + filedir + " is not a directory")
return False
subfolders = os.listdir(filedir)
for subfolder in subfolders:
if subfolder not in metadata:
print("Error: folder " + subfolder +
" present on disk but not in metadata")
return False
for subfolder in metadata:
if subfolder not in subfolders:
print("Error: folder " + subfolder +
" present in metadata but not on disk")
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def review_metadata_csv_multi_user(filedir, metadata, csv_in, n_headers):
""" Check validity of metadata for multi user. :param filedir: This field is the filepath of the directory whose csv has to be made. :param metadata: This field is the metadata generated from the load_metadata_csv function. :param csv_in: This field returns a reader object which iterates over the csv. :param n_headers: This field is the number of headers in the csv. """ |
try:
if not validate_subfolders(filedir, metadata):
return False
for project_member_id, member_metadata in metadata.items():
if not validate_metadata(os.path.join
(filedir, project_member_id),
member_metadata):
return False
for filename, file_metadata in member_metadata.items():
is_single_file_metadata_valid(file_metadata, project_member_id,
filename)
except ValueError as e:
print_error(e)
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def review_metadata_csv(filedir, input_filepath):
""" Check validity of metadata fields. :param filedir: This field is the filepath of the directory whose csv has to be made. :param outputfilepath: This field is the file path of the output csv. :param max_bytes: This field is the maximum file size to consider. Its default value is 128m. """ |
try:
metadata = load_metadata_csv(input_filepath)
except ValueError as e:
print_error(e)
return False
with open(input_filepath) as f:
csv_in = csv.reader(f)
header = next(csv_in)
n_headers = len(header)
if header[0] == 'filename':
res = review_metadata_csv_single_user(filedir, metadata,
csv_in, n_headers)
return res
if header[0] == 'project_member_id':
res = review_metadata_csv_multi_user(filedir, metadata,
csv_in, n_headers)
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def mk_metadata_csv(filedir, outputfilepath, max_bytes=MAX_FILE_DEFAULT):
""" Make metadata file for all files in a directory. :param filedir: This field is the filepath of the directory whose csv has to be made. :param outputfilepath: This field is the file path of the output csv. :param max_bytes: This field is the maximum file size to consider. Its default value is 128m. """ |
with open(outputfilepath, 'w') as filestream:
write_metadata_to_filestream(filedir, filestream, max_bytes) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_id_list(filepath):
""" Get project member id from a file. :param filepath: This field is the path of file to read. """ |
if not filepath:
return None
id_list = []
with open(filepath) as f:
for line in f:
line = line.rstrip()
if not re.match('^[0-9]{8}$', line):
raise('Each line in whitelist or blacklist is expected '
'to contain an eight digit ID, and nothing else.')
else:
id_list.append(line)
return id_list |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_log_level(debug, verbose):
""" Function for setting the logging level. :param debug: This boolean field is the logging level. :param verbose: This boolean field is the logging level. """ |
if debug:
logging.basicConfig(level=logging.DEBUG)
elif verbose:
logging.basicConfig(level=logging.INFO) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download(directory, master_token=None, member=None, access_token=None, source=None, project_data=False, max_size='128m', verbose=False, debug=False, memberlist=None, excludelist=None, id_filename=False):
""" Download data from project members to the target directory. Unless this is a member-specific download, directories will be created for each project member ID. Also, unless a source is specified, all shared sources are downloaded and data is sorted into subdirectories according to source. Projects can optionally return data to Open Humans member accounts. If project_data is True (or the "--project-data" flag is used), this data (the project's own data files, instead of data from other sources) will be downloaded for each member. :param directory: This field is the target directory to download data. :param master_token: This field is the master access token for the project. It's default value is None. :param member: This field is specific member whose project data is downloaded. It's default value is None. :param access_token: This field is the user specific access token. It's default value is None. :param source: This field is the data source. It's default value is None. :param project_data: This field is data related to particular project. It's default value is False. :param max_size: This field is the maximum file size. It's default value is 128m. :param verbose: This boolean field is the logging level. It's default value is False. :param debug: This boolean field is the logging level. It's default value is False. :param memberlist: This field is list of members whose data will be downloaded. It's default value is None. :param excludelist: This field is list of members whose data will be skipped. It's default value is None. """ |
set_log_level(debug, verbose)
if (memberlist or excludelist) and (member or access_token):
raise UsageError('Please do not provide a memberlist or excludelist '
'when retrieving data for a single member.')
memberlist = read_id_list(memberlist)
excludelist = read_id_list(excludelist)
if not (master_token or access_token) or (master_token and access_token):
raise UsageError('Please specify either a master access token (-T), '
'or an OAuth2 user access token (-t).')
if (source and project_data):
raise UsageError("It doesn't make sense to use both 'source' and"
"'project-data' options!")
if master_token:
project = OHProject(master_access_token=master_token)
if member:
if project_data:
project.download_member_project_data(
member_data=project.project_data[member],
target_member_dir=directory,
max_size=max_size,
id_filename=id_filename)
else:
project.download_member_shared(
member_data=project.project_data[member],
target_member_dir=directory,
source=source,
max_size=max_size,
id_filename=id_filename)
else:
project.download_all(target_dir=directory,
source=source,
max_size=max_size,
memberlist=memberlist,
excludelist=excludelist,
project_data=project_data,
id_filename=id_filename)
else:
member_data = exchange_oauth2_member(access_token, all_files=True)
if project_data:
OHProject.download_member_project_data(member_data=member_data,
target_member_dir=directory,
max_size=max_size,
id_filename=id_filename)
else:
OHProject.download_member_shared(member_data=member_data,
target_member_dir=directory,
source=source,
max_size=max_size,
id_filename=id_filename) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_metadata(master_token, output_csv, verbose=False, debug=False):
""" Output CSV with metadata for a project's downloadable files in Open Humans. :param master_token: This field is the master access token for the project. :param output_csv: This field is the target csv file to which metadata is written. :param verbose: This boolean field is the logging level. It's default value is False. :param debug: This boolean field is the logging level. It's default value is False. """ |
set_log_level(debug, verbose)
project = OHProject(master_access_token=master_token)
with open(output_csv, 'w') as f:
csv_writer = csv.writer(f)
header = ['project_member_id', 'data_source', 'file_basename',
'file_upload_date']
csv_writer.writerow(header)
for member_id in project.project_data:
if not project.project_data[member_id]['data']:
csv_writer.writerow([member_id, 'NA', 'None', 'NA'])
else:
for data_item in project.project_data[member_id]['data']:
logging.debug(data_item)
csv_writer.writerow([
member_id, data_item['source'],
data_item['basename'].encode('utf-8'),
data_item['created']]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def upload(directory, metadata_csv, master_token=None, member=None, access_token=None, safe=False, sync=False, max_size='128m', mode='default', verbose=False, debug=False):
""" Upload files for the project to Open Humans member accounts. If using a master access token and not specifying member ID: (1) Files should be organized in subdirectories according to project member ID, e.g.: main_directory/01234567/data.json main_directory/12345678/data.json main_directory/23456789/data.json (2) The metadata CSV should have the following format: 1st column: Project member ID 2nd column: filenames 3rd & additional columns: Metadata fields (see below) If uploading for a specific member: (1) The local directory should not contain subdirectories. (2) The metadata CSV should have the following format: 1st column: filenames 2nd & additional columns: Metadata fields (see below) The default behavior is to overwrite files with matching filenames on Open Humans, but not otherwise delete files. (Use --safe or --sync to change this behavior.) If included, the following metadata columns should be correctly formatted: 'tags': should be comma-separated strings 'md5': should match the file's md5 hexdigest 'creation_date', 'start_date', 'end_date': ISO 8601 dates or datetimes Other metedata fields (e.g. 'description') can be arbitrary strings. Either specify sync as True or safe as True but not both. :param directory: This field is the target directory from which data will be uploaded. :param metadata_csv: This field is the filepath of the metadata csv file. :param master_token: This field is the master access token for the project. It's default value is None. :param member: This field is specific member whose project data is downloaded. It's default value is None. :param access_token: This field is the user specific access token. It's default value is None. :param safe: This boolean field will overwrite matching filename. It's default value is False. :param sync: This boolean field will delete files on Open Humans that are not in the local directory. It's default value is False. :param max_size: This field is the maximum file size. It's default value is None. :param mode: This field takes three value default, sync, safe. It's default value is 'default'. :param verbose: This boolean field is the logging level. It's default value is False. :param debug: This boolean field is the logging level. It's default value is False. """ |
if safe and sync:
raise UsageError('Safe (--safe) and sync (--sync) modes are mutually '
'incompatible!')
if not (master_token or access_token) or (master_token and access_token):
raise UsageError('Please specify either a master access token (-T), '
'or an OAuth2 user access token (-t).')
set_log_level(debug, verbose)
if sync:
mode = 'sync'
elif safe:
mode = 'safe'
metadata = load_metadata_csv(metadata_csv)
subdirs = [i for i in os.listdir(directory) if
os.path.isdir(os.path.join(directory, i))]
if subdirs:
if not all([re.match(r'^[0-9]{8}$', d) for d in subdirs]):
raise UsageError(
"Subdirs expected to match project member ID format!")
if (master_token and member) or not master_token:
raise UsageError(
"Subdirs shouldn't exist if uploading for specific member!")
project = OHProject(master_access_token=master_token)
for member_id in subdirs:
subdir_path = os.path.join(directory, member_id)
project.upload_member_from_dir(
member_data=project.project_data[member_id],
target_member_dir=subdir_path,
metadata=metadata[member_id],
mode=mode,
access_token=project.master_access_token,
)
else:
if master_token and not (master_token and member):
raise UsageError('No member specified!')
if master_token:
project = OHProject(master_access_token=master_token)
project.upload_member_from_dir(
member_data=project.project_data[member],
target_member_dir=directory,
metadata=metadata,
mode=mode,
access_token=project.master_access_token,
)
else:
member_data = exchange_oauth2_member(access_token)
OHProject.upload_member_from_dir(
member_data=member_data,
target_member_dir=directory,
metadata=metadata,
mode=mode,
access_token=access_token,
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def public_data_download_cli(source, username, directory, max_size, quiet, debug):
""" Command line tools for downloading public data. """ |
return public_download(source, username, directory, max_size, quiet, debug) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download(source=None, username=None, directory='.', max_size='128m', quiet=None, debug=None):
""" Download public data from Open Humans. :param source: This field is the data source from which to download. It's default value is None. :param username: This fiels is username of user. It's default value is None. :param directory: This field is the target directory to which data is downloaded. :param max_size: This field is the maximum file size. It's default value is 128m. :param quiet: This field is the logging level. It's default value is None. :param debug: This field is the logging level. It's default value is None. """ |
if debug:
logging.basicConfig(level=logging.DEBUG)
elif quiet:
logging.basicConfig(level=logging.ERROR)
else:
logging.basicConfig(level=logging.INFO)
logging.debug("Running with source: '{}'".format(source) +
" and username: '{}'".format(username) +
" and directory: '{}'".format(directory) +
" and max-size: '{}'".format(max_size))
signal.signal(signal.SIGINT, signal_handler_cb)
max_bytes = parse_size(max_size)
options = {}
if source:
options['source'] = source
if username:
options['username'] = username
page = '{}?{}'.format(BASE_URL_API, urlencode(options))
results = []
counter = 1
logging.info('Retrieving metadata')
while True:
logging.info('Retrieving page {}'.format(counter))
response = get_page(page)
results = results + response['results']
if response['next']:
page = response['next']
else:
break
counter += 1
logging.info('Downloading {} files'.format(len(results)))
download_url_partial = partial(download_url, directory=directory,
max_bytes=max_bytes)
with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
for value in executor.map(download_url_partial, results):
if value:
logging.info(value) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_members_by_source(base_url=BASE_URL_API):
""" Function returns which members have joined each activity. :param base_url: It is URL: `https://www.openhumans.org/api/public-data`. """ |
url = '{}members-by-source/'.format(base_url)
response = get_page(url)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_sources_by_member(base_url=BASE_URL_API, limit=LIMIT_DEFAULT):
""" Function returns which activities each member has joined. :param base_url: It is URL: `https://www.openhumans.org/api/public-data`. :param limit: It is the limit of data send by one request. """ |
url = '{}sources-by-member/'.format(base_url)
page = '{}?{}'.format(url, urlencode({'limit': limit}))
results = []
while True:
data = get_page(page)
results = results + data['results']
if data['next']:
page = data['next']
else:
break
return results |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_member_file_data(member_data, id_filename=False):
""" Helper function to get file data of member of a project. :param member_data: This field is data related to member in a project. """ |
file_data = {}
for datafile in member_data['data']:
if id_filename:
basename = '{}.{}'.format(datafile['id'], datafile['basename'])
else:
basename = datafile['basename']
if (basename not in file_data or
arrow.get(datafile['created']) >
arrow.get(file_data[basename]['created'])):
file_data[basename] = datafile
return file_data |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_data(self):
""" Returns data for all users including shared data files. """ |
url = ('https://www.openhumans.org/api/direct-sharing/project/'
'members/?access_token={}'.format(self.master_access_token))
results = get_all_results(url)
self.project_data = dict()
for result in results:
self.project_data[result['project_member_id']] = result
if len(result['data']) < result['file_count']:
member_data = get_page(result['exchange_member'])
final_data = member_data['data']
while member_data['next']:
member_data = get_page(member_data['next'])
final_data = final_data + member_data['data']
self.project_data[
result['project_member_id']]['data'] = final_data
return self.project_data |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_member_project_data(cls, member_data, target_member_dir, max_size=MAX_SIZE_DEFAULT, id_filename=False):
""" Download files to sync a local dir to match OH member project data. :param member_data: This field is data related to member in a project. :param target_member_dir: This field is the target directory where data will be downloaded. :param max_size: This field is the maximum file size. It's default value is 128m. """ |
logging.debug('Download member project data...')
sources_shared = member_data['sources_shared']
file_data = cls._get_member_file_data(member_data,
id_filename=id_filename)
for basename in file_data:
# This is using a trick to identify a project's own data in an API
# response, without knowing the project's identifier: if the data
# isn't a shared data source, it must be the project's own data.
if file_data[basename]['source'] in sources_shared:
continue
target_filepath = os.path.join(target_member_dir, basename)
download_file(download_url=file_data[basename]['download_url'],
target_filepath=target_filepath,
max_bytes=parse_size(max_size)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_member_shared(cls, member_data, target_member_dir, source=None, max_size=MAX_SIZE_DEFAULT, id_filename=False):
""" Download files to sync a local dir to match OH member shared data. Files are downloaded to match their "basename" on Open Humans. If there are multiple files with the same name, the most recent is downloaded. :param member_data: This field is data related to member in a project. :param target_member_dir: This field is the target directory where data will be downloaded. :param source: This field is the source from which to download data. :param max_size: This field is the maximum file size. It's default value is 128m. """ |
logging.debug('Download member shared data...')
sources_shared = member_data['sources_shared']
file_data = cls._get_member_file_data(member_data,
id_filename=id_filename)
logging.info('Downloading member data to {}'.format(target_member_dir))
for basename in file_data:
# If not in sources shared, it's the project's own data. Skip.
if file_data[basename]['source'] not in sources_shared:
continue
# Filter source if specified. Determine target directory for file.
if source:
if source == file_data[basename]['source']:
target_filepath = os.path.join(target_member_dir, basename)
else:
continue
else:
source_data_dir = os.path.join(target_member_dir,
file_data[basename]['source'])
if not os.path.exists(source_data_dir):
os.mkdir(source_data_dir)
target_filepath = os.path.join(source_data_dir, basename)
download_file(download_url=file_data[basename]['download_url'],
target_filepath=target_filepath,
max_bytes=parse_size(max_size)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_all(self, target_dir, source=None, project_data=False, memberlist=None, excludelist=None, max_size=MAX_SIZE_DEFAULT, id_filename=False):
""" Download data for all users including shared data files. :param target_dir: This field is the target directory to download data. :param source: This field is the data source. It's default value is None. :param project_data: This field is data related to particular project. It's default value is False. :param memberlist: This field is list of members whose data will be downloaded. It's default value is None. :param excludelist: This field is list of members whose data will be skipped. It's default value is None. :param max_size: This field is the maximum file size. It's default value is 128m. """ |
members = self.project_data.keys()
for member in members:
if not (memberlist is None) and member not in memberlist:
logging.debug('Skipping {}, not in memberlist'.format(member))
continue
if excludelist and member in excludelist:
logging.debug('Skipping {}, in excludelist'.format(member))
continue
member_dir = os.path.join(target_dir, member)
if not os.path.exists(member_dir):
os.mkdir(member_dir)
if project_data:
self.download_member_project_data(
member_data=self.project_data[member],
target_member_dir=member_dir,
max_size=max_size,
id_filename=id_filename)
else:
self.download_member_shared(
member_data=self.project_data[member],
target_member_dir=member_dir,
source=source,
max_size=max_size,
id_filename=id_filename) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def upload_member_from_dir(member_data, target_member_dir, metadata, access_token, mode='default', max_size=MAX_SIZE_DEFAULT):
""" Upload files in target directory to an Open Humans member's account. The default behavior is to overwrite files with matching filenames on Open Humans, but not otherwise delete files. If the 'mode' parameter is 'safe': matching filenames will not be overwritten. If the 'mode' parameter is 'sync': files on Open Humans that are not in the local directory will be deleted. :param member_data: This field is data related to member in a project. :param target_member_dir: This field is the target directory from where data will be uploaded. :param metadata: This field is metadata for files to be uploaded. :param access_token: This field is user specific access token. :param mode: This field takes three value default, sync, safe. It's default value is 'default'. :param max_size: This field is the maximum file size. It's default value is 128m. """ |
if not validate_metadata(target_member_dir, metadata):
raise ValueError('Metadata should match directory contents!')
project_data = {f['basename']: f for f in member_data['data'] if
f['source'] not in member_data['sources_shared']}
for filename in metadata:
if filename in project_data and mode == 'safe':
logging.info('Skipping {}, remote exists with matching'
' name'.format(filename))
continue
filepath = os.path.join(target_member_dir, filename)
remote_file_info = (project_data[filename] if filename in
project_data else None)
upload_aws(target_filepath=filepath,
metadata=metadata[filename],
access_token=access_token,
project_member_id=member_data['project_member_id'],
remote_file_info=remote_file_info)
if mode == 'sync':
for filename in project_data:
if filename not in metadata:
logging.debug("Deleting {}".format(filename))
delete_file(
file_basename=filename,
access_token=access_token,
project_member_id=member_data['project_member_id']) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_page(url):
""" Get a single page of results. :param url: This field is the url from which data will be requested. """ |
response = requests.get(url)
handle_error(response, 200)
data = response.json()
return data |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_all_results(starting_page):
""" Given starting API query for Open Humans, iterate to get all results. :param starting page: This field is the first page, starting from which results will be obtained. """ |
logging.info('Retrieving all results for {}'.format(starting_page))
page = starting_page
results = []
while True:
logging.debug('Getting data from: {}'.format(page))
data = get_page(page)
logging.debug('JSON data: {}'.format(data))
results = results + data['results']
if data['next']:
page = data['next']
else:
break
return results |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def exchange_oauth2_member(access_token, base_url=OH_BASE_URL, all_files=False):
""" Returns data for a specific user, including shared data files. :param access_token: This field is the user specific access_token. :param base_url: It is this URL `https://www.openhumans.org`. """ |
url = urlparse.urljoin(
base_url,
'/api/direct-sharing/project/exchange-member/?{}'.format(
urlparse.urlencode({'access_token': access_token})))
member_data = get_page(url)
returned = member_data.copy()
# Get all file data if all_files is True.
if all_files:
while member_data['next']:
member_data = get_page(member_data['next'])
returned['data'] = returned['data'] + member_data['data']
logging.debug('JSON data: {}'.format(returned))
return returned |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def handle_error(r, expected_code):
""" Helper function to match reponse of a request to the expected status code :param r: This field is the response of request. :param expected_code: This field is the expected status code for the function. """ |
code = r.status_code
if code != expected_code:
info = 'API response status code {}'.format(code)
try:
if 'detail' in r.json():
info = info + ": {}".format(r.json()['detail'])
elif 'metadata' in r.json():
info = info + ": {}".format(r.json()['metadata'])
except json.decoder.JSONDecodeError:
info = info + ":\n{}".format(r.content)
raise Exception(info) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pack_list(from_, pack_type):
""" Return the wire packed version of `from_`. `pack_type` should be some subclass of `xcffib.Struct`, or a string that can be passed to `struct.pack`. You must pass `size` if `pack_type` is a struct.pack string. """ |
# We need from_ to not be empty
if len(from_) == 0:
return bytes()
if pack_type == 'c':
if isinstance(from_, bytes):
# Catch Python 3 bytes and Python 2 strings
# PY3 is "helpful" in that when you do tuple(b'foo') you get
# (102, 111, 111) instead of something more reasonable like
# (b'f', b'o', b'o'), so we rebuild from_ as a tuple of bytes
from_ = [six.int2byte(b) for b in six.iterbytes(from_)]
elif isinstance(from_, six.string_types):
# Catch Python 3 strings and Python 2 unicode strings, both of
# which we encode to bytes as utf-8
# Here we create the tuple of bytes from the encoded string
from_ = [six.int2byte(b) for b in bytearray(from_, 'utf-8')]
elif isinstance(from_[0], six.integer_types):
# Pack from_ as char array, where from_ may be an array of ints
# possibly greater than 256
def to_bytes(v):
for _ in range(4):
v, r = divmod(v, 256)
yield r
from_ = [six.int2byte(b) for i in from_ for b in to_bytes(i)]
if isinstance(pack_type, six.string_types):
return struct.pack("=" + pack_type * len(from_), *from_)
else:
buf = six.BytesIO()
for item in from_:
# If we can't pack it, you'd better have packed it yourself. But
# let's not confuse things which aren't our Probobjs for packable
# things.
if isinstance(item, Protobj) and hasattr(item, "pack"):
buf.write(item.pack())
else:
buf.write(item)
return buf.getvalue() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ensure_connected(f):
""" Check that the connection is valid both before and after the function is invoked. """ |
@functools.wraps(f)
def wrapper(*args):
self = args[0]
self.invalid()
try:
return f(*args)
finally:
self.invalid()
return wrapper |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_screen_pointers(self):
""" Returns the xcb_screen_t for every screen useful for other bindings """ |
root_iter = lib.xcb_setup_roots_iterator(self._setup)
screens = [root_iter.data]
for i in range(self._setup.roots_len - 1):
lib.xcb_screen_next(ffi.addressof((root_iter)))
screens.append(root_iter.data)
return screens |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.