text_prompt
stringlengths 100
17.7k
⌀ | code_prompt
stringlengths 7
9.86k
⌀ |
|---|---|
<SYSTEM_TASK:>
Add images to the album.
<END_TASK>
<USER_TASK:>
Description:
def add_images(self, images):
"""
Add images to the album.
:param images: A list of the images we want to add to the album. Can be
Image objects, ids or a combination of the two. Images that you
cannot add (non-existing or not owned by you) will not cause
exceptions, but fail silently.
""" |
url = self._imgur._base_url + "/3/album/{0}/add".format(self.id)
params = {'ids': images}
return self._imgur._send_request(url, needs_auth=True, params=params,
method="POST") |
<SYSTEM_TASK:>
Remove images from the album.
<END_TASK>
<USER_TASK:>
Description:
def remove_images(self, images):
"""
Remove images from the album.
:param images: A list of the images we want to remove from the album.
Can be Image objects, ids or a combination of the two. Images that
you cannot remove (non-existing, not owned by you or not part of
album) will not cause exceptions, but fail silently.
""" |
url = (self._imgur._base_url + "/3/album/{0}/"
"remove_images".format(self._delete_or_id_hash))
# NOTE: Returns True and everything seem to be as it should in testing.
# Seems most likely to be upstream bug.
params = {'ids': images}
return self._imgur._send_request(url, params=params, method="DELETE") |
<SYSTEM_TASK:>
Set the images in this album.
<END_TASK>
<USER_TASK:>
Description:
def set_images(self, images):
"""
Set the images in this album.
:param images: A list of the images we want the album to contain.
Can be Image objects, ids or a combination of the two. Images that
images that you cannot set (non-existing or not owned by you) will
not cause exceptions, but fail silently.
""" |
url = (self._imgur._base_url + "/3/album/"
"{0}/".format(self._delete_or_id_hash))
params = {'ids': images}
return self._imgur._send_request(url, needs_auth=True, params=params,
method="POST") |
<SYSTEM_TASK:>
Add this to the gallery.
<END_TASK>
<USER_TASK:>
Description:
def submit_to_gallery(self, title, bypass_terms=False):
"""
Add this to the gallery.
Require that the authenticated user has accepted gallery terms and
verified their email.
:param title: The title of the new gallery item.
:param bypass_terms: If the user has not accepted Imgur's terms yet,
this method will return an error. Set this to True to by-pass the
terms.
""" |
url = self._imgur._base_url + "/3/gallery/{0}".format(self.id)
payload = {'title': title, 'terms': '1' if bypass_terms else '0'}
self._imgur._send_request(url, needs_auth=True, params=payload,
method='POST')
item = self._imgur.get_gallery_album(self.id)
_change_object(self, item)
return self |
<SYSTEM_TASK:>
Update the album's information.
<END_TASK>
<USER_TASK:>
Description:
def update(self, title=None, description=None, images=None, cover=None,
layout=None, privacy=None):
"""
Update the album's information.
Arguments with the value None will retain their old values.
:param title: The title of the album.
:param description: A description of the album.
:param images: A list of the images we want the album to contain.
Can be Image objects, ids or a combination of the two. Images that
images that you cannot set (non-existing or not owned by you) will
not cause exceptions, but fail silently.
:param privacy: The albums privacy level, can be public, hidden or
secret.
:param cover: The id of the cover image.
:param layout: The way the album is displayed, can be blog, grid,
horizontal or vertical.
""" |
url = (self._imgur._base_url + "/3/album/"
"{0}".format(self._delete_or_id_hash))
is_updated = self._imgur._send_request(url, params=locals(),
method='POST')
if is_updated:
self.title = title or self.title
self.description = description or self.description
self.layout = layout or self.layout
self.privacy = privacy or self.privacy
if cover is not None:
self.cover = (cover if isinstance(cover, Image)
else Image({'id': cover}, self._imgur,
has_fetched=False))
if images:
self.images = [img if isinstance(img, Image) else
Image({'id': img}, self._imgur, False)
for img in images]
return is_updated |
<SYSTEM_TASK:>
Get the replies to this comment.
<END_TASK>
<USER_TASK:>
Description:
def get_replies(self):
"""Get the replies to this comment.""" |
url = self._imgur._base_url + "/3/comment/{0}/replies".format(self.id)
json = self._imgur._send_request(url)
child_comments = json['children']
return [Comment(com, self._imgur) for com in child_comments] |
<SYSTEM_TASK:>
Make a top-level comment to this.
<END_TASK>
<USER_TASK:>
Description:
def comment(self, text):
"""
Make a top-level comment to this.
:param text: The comment text.
""" |
url = self._imgur._base_url + "/3/comment"
payload = {'image_id': self.id, 'comment': text}
resp = self._imgur._send_request(url, params=payload, needs_auth=True,
method='POST')
return Comment(resp, imgur=self._imgur, has_fetched=False) |
<SYSTEM_TASK:>
Dislike this.
<END_TASK>
<USER_TASK:>
Description:
def downvote(self):
"""
Dislike this.
A downvote will replace a neutral vote or an upvote. Downvoting
something the authenticated user has already downvoted will set the
vote to neutral.
""" |
url = self._imgur._base_url + "/3/gallery/{0}/vote/down".format(self.id)
return self._imgur._send_request(url, needs_auth=True, method='POST') |
<SYSTEM_TASK:>
Get a list of the top-level comments.
<END_TASK>
<USER_TASK:>
Description:
def get_comments(self):
"""Get a list of the top-level comments.""" |
url = self._imgur._base_url + "/3/gallery/{0}/comments".format(self.id)
resp = self._imgur._send_request(url)
return [Comment(com, self._imgur) for com in resp] |
<SYSTEM_TASK:>
Remove this image from the gallery.
<END_TASK>
<USER_TASK:>
Description:
def remove_from_gallery(self):
"""Remove this image from the gallery.""" |
url = self._imgur._base_url + "/3/gallery/{0}".format(self.id)
self._imgur._send_request(url, needs_auth=True, method='DELETE')
if isinstance(self, Image):
item = self._imgur.get_image(self.id)
else:
item = self._imgur.get_album(self.id)
_change_object(self, item)
return self |
<SYSTEM_TASK:>
Download the image.
<END_TASK>
<USER_TASK:>
Description:
def download(self, path='', name=None, overwrite=False, size=None):
"""
Download the image.
:param path: The image will be downloaded to the folder specified at
path, if path is None (default) then the current working directory
will be used.
:param name: The name the image will be stored as (not including file
extension). If name is None, then the title of the image will be
used. If the image doesn't have a title, it's id will be used. Note
that if the name given by name or title is an invalid filename,
then the hash will be used as the name instead.
:param overwrite: If True overwrite already existing file with the same
name as what we want to save the file as.
:param size: Instead of downloading the image in it's original size, we
can choose to instead download a thumbnail of it. Options are
'small_square', 'big_square', 'small_thumbnail',
'medium_thumbnail', 'large_thumbnail' or 'huge_thumbnail'.
:returns: Name of the new file.
""" |
def save_as(filename):
local_path = os.path.join(path, filename)
if os.path.exists(local_path) and not overwrite:
raise Exception("Trying to save as {0}, but file "
"already exists.".format(local_path))
with open(local_path, 'wb') as out_file:
out_file.write(resp.content)
return local_path
valid_sizes = {'small_square': 's', 'big_square': 'b',
'small_thumbnail': 't', 'medium_thumbnail': 'm',
'large_thumbnail': 'l', 'huge_thumbnail': 'h'}
if size is not None:
size = size.lower().replace(' ', '_')
if size not in valid_sizes:
raise LookupError('Invalid size. Valid options are: {0}'.format(
", " .join(valid_sizes.keys())))
suffix = valid_sizes.get(size, '')
base, sep, ext = self.link.rpartition('.')
resp = requests.get(base + suffix + sep + ext)
if name or self.title:
try:
return save_as((name or self.title) + suffix + sep + ext)
except IOError:
pass
# Invalid filename
return save_as(self.id + suffix + sep + ext) |
<SYSTEM_TASK:>
Handles top level functionality for sending requests to Imgur.
<END_TASK>
<USER_TASK:>
Description:
def _send_request(self, url, needs_auth=False, **kwargs):
"""
Handles top level functionality for sending requests to Imgur.
This mean
- Raising client-side error if insufficient authentication.
- Adding authentication information to the request.
- Split the request into multiple request for pagination.
- Retry calls for certain server-side errors.
- Refresh access token automatically if expired.
- Updating ratelimit info
:param needs_auth: Is authentication as a user needed for the execution
of this method?
""" |
# TODO: Add automatic test for timed_out access_tokens and
# automatically refresh it before carrying out the request.
if self.access_token is None and needs_auth:
# TODO: Use inspect to insert name of method in error msg.
raise Exception("Authentication as a user is required to use this "
"method.")
if self.access_token is None:
# Not authenticated as a user. Use anonymous access.
auth = {'Authorization': 'Client-ID {0}'.format(self.client_id)}
else:
auth = {'Authorization': 'Bearer {0}'.format(self.access_token)}
if self.mashape_key:
auth.update({'X-Mashape-Key': self.mashape_key})
content = []
is_paginated = False
if 'limit' in kwargs:
is_paginated = True
limit = kwargs['limit'] or self.DEFAULT_LIMIT
del kwargs['limit']
page = 0
base_url = url
url.format(page)
kwargs['authentication'] = auth
while True:
result = request.send_request(url, verify=self.verify, **kwargs)
new_content, ratelimit_info = result
if is_paginated and new_content and limit > len(new_content):
content += new_content
page += 1
url = base_url.format(page)
else:
if is_paginated:
content = (content + new_content)[:limit]
else:
content = new_content
break
# Note: When the cache is implemented, it's important that the
# ratelimit info doesn't get updated with the ratelimit info in the
# cache since that's likely incorrect.
for key, value in ratelimit_info.items():
setattr(self, key[2:].replace('-', '_'), value)
return content |
<SYSTEM_TASK:>
Return the authorization url that's needed to authorize as a user.
<END_TASK>
<USER_TASK:>
Description:
def authorization_url(self, response, state=""):
"""
Return the authorization url that's needed to authorize as a user.
:param response: Can be either code or pin. If it's code the user will
be redirected to your redirect url with the code as a get parameter
after authorizing your application. If it's pin then after
authorizing your application, the user will instead be shown a pin
on Imgurs website. Both code and pin are used to get an
access_token and refresh token with the exchange_code and
exchange_pin functions respectively.
:param state: This optional parameter indicates any state which may be
useful to your application upon receipt of the response. Imgur
round-trips this parameter, so your application receives the same
value it sent. Possible uses include redirecting the user to the
correct resource in your site, nonces, and
cross-site-request-forgery mitigations.
""" |
return AUTHORIZE_URL.format(self._base_url, self.client_id, response, state) |
<SYSTEM_TASK:>
Change the current authentication.
<END_TASK>
<USER_TASK:>
Description:
def change_authentication(self, client_id=None, client_secret=None,
access_token=None, refresh_token=None):
"""Change the current authentication.""" |
# TODO: Add error checking so you cannot change client_id and retain
# access_token. Because that doesn't make sense.
self.client_id = client_id or self.client_id
self.client_secret = client_secret or self.client_secret
self.access_token = access_token or self.access_token
self.refresh_token = refresh_token or self.refresh_token |
<SYSTEM_TASK:>
Create a new Album.
<END_TASK>
<USER_TASK:>
Description:
def create_album(self, title=None, description=None, images=None,
cover=None):
"""
Create a new Album.
:param title: The title of the album.
:param description: The albums description.
:param images: A list of the images that will be added to the album
after it's created. Can be Image objects, ids or a combination of
the two. Images that you cannot add (non-existing or not owned by
you) will not cause exceptions, but fail silently.
:param cover: The id of the image you want as the albums cover image.
:returns: The newly created album.
""" |
url = self._base_url + "/3/album/"
payload = {'ids': images, 'title': title,
'description': description, 'cover': cover}
resp = self._send_request(url, params=payload, method='POST')
return Album(resp, self, has_fetched=False) |
<SYSTEM_TASK:>
Exchange one-use code for an access_token and request_token.
<END_TASK>
<USER_TASK:>
Description:
def exchange_code(self, code):
"""Exchange one-use code for an access_token and request_token.""" |
params = {'client_id': self.client_id,
'client_secret': self.client_secret,
'grant_type': 'authorization_code',
'code': code}
result = self._send_request(EXCHANGE_URL.format(self._base_url),
params=params, method='POST',
data_field=None)
self.access_token = result['access_token']
self.refresh_token = result['refresh_token']
return self.access_token, self.refresh_token |
<SYSTEM_TASK:>
Exchange one-use pin for an access_token and request_token.
<END_TASK>
<USER_TASK:>
Description:
def exchange_pin(self, pin):
"""Exchange one-use pin for an access_token and request_token.""" |
params = {'client_id': self.client_id,
'client_secret': self.client_secret,
'grant_type': 'pin',
'pin': pin}
result = self._send_request(EXCHANGE_URL.format(self._base_url),
params=params, method='POST',
data_field=None)
self.access_token = result['access_token']
self.refresh_token = result['refresh_token']
return self.access_token, self.refresh_token |
<SYSTEM_TASK:>
Return information about this album.
<END_TASK>
<USER_TASK:>
Description:
def get_album(self, id):
"""Return information about this album.""" |
url = self._base_url + "/3/album/{0}".format(id)
json = self._send_request(url)
return Album(json, self) |
<SYSTEM_TASK:>
Return a object representing the content at url.
<END_TASK>
<USER_TASK:>
Description:
def get_at_url(self, url):
"""
Return a object representing the content at url.
Returns None if no object could be matched with the id.
Works for Album, Comment, Gallery_album, Gallery_image, Image and User.
NOTE: Imgur's documentation does not cover what urls are available.
Some urls, such as imgur.com/<ID> can be for several different types of
object. Using a wrong, but similair call, such as get_subreddit_image
on a meme image will not cause an error. But instead return a subset of
information, with either the remaining pieces missing or the value set
to None. This makes it hard to create a method such as this that
attempts to deduce the object from the url. Due to these factors, this
method should be considered experimental and used carefully.
:param url: The url where the content is located at
""" |
class NullDevice():
def write(self, string):
pass
def get_gallery_item(id):
"""
Special helper method to get gallery items.
The problem is that it's impossible to distinguish albums and
images from each other based on the url. And there isn't a common
url endpoints that return either a Gallery_album or a Gallery_image
depending on what the id represents. So the only option is to
assume it's a Gallery_image and if we get an exception then try
Gallery_album. Gallery_image is attempted first because there is
the most of them.
"""
try:
# HACK: Problem is that send_request prints the error message
# from Imgur when it encounters an error. This is nice because
# this error message is more descriptive than just the status
# code that Requests give. But since we first assume the id
# belong to an image, it means we will get an error whenever
# the id belongs to an album. The following code temporarily
# disables stdout to avoid give a cryptic and incorrect error.
# Code for disabling stdout is from
# http://coreygoldberg.blogspot.dk/2009/05/
# python-redirect-or-turn-off-stdout-and.html
original_stdout = sys.stdout # keep a reference to STDOUT
sys.stdout = NullDevice() # redirect the real STDOUT
return self.get_gallery_image(id)
# TODO: Add better error codes so I don't have to do a catch-all
except Exception:
return self.get_gallery_album(id)
finally:
sys.stdout = original_stdout # turn STDOUT back on
if not self.is_imgur_url(url):
return None
objects = {'album': {'regex': "a/(?P<id>[\w.]*?)$",
'method': self.get_album},
'comment': {'regex': "gallery/\w*/comment/(?P<id>[\w.]*?)$",
'method': self.get_comment},
'gallery': {'regex': "(gallery|r/\w*?)/(?P<id>[\w.]*?)$",
'method': get_gallery_item},
# Valid image extensions: http://imgur.com/faq#types
# All are between 3 and 4 chars long.
'image': {'regex': "(?P<id>[\w.]*?)(\\.\w{3,4})?$",
'method': self.get_image},
'user': {'regex': "user/(?P<id>[\w.]*?)$",
'method': self.get_user}
}
parsed_url = urlparse(url)
for obj_type, values in objects.items():
regex_result = re.match('/' + values['regex'], parsed_url.path)
if regex_result is not None:
obj_id = regex_result.group('id')
initial_object = values['method'](obj_id)
if obj_type == 'image':
try:
# A better version might be to ping the url where the
# gallery_image should be with a requests.head call. If
# we get a 200 returned, then that means it exists and
# this becomes less hacky.
original_stdout = sys.stdout
sys.stdout = NullDevice()
if getattr(initial_object, 'section', None):
sub = initial_object.section
return self.get_subreddit_image(sub, obj_id)
return self.get_gallery_image(obj_id)
except Exception:
pass
finally:
sys.stdout = original_stdout
return initial_object |
<SYSTEM_TASK:>
Return a list of gallery albums and gallery images.
<END_TASK>
<USER_TASK:>
Description:
def get_gallery(self, section='hot', sort='viral', window='day',
show_viral=True, limit=None):
"""
Return a list of gallery albums and gallery images.
:param section: hot | top | user - defaults to hot.
:param sort: viral | time - defaults to viral.
:param window: Change the date range of the request if the section is
"top", day | week | month | year | all, defaults to day.
:param show_viral: true | false - Show or hide viral images from the
'user' section. Defaults to true.
:param limit: The number of items to return.
""" |
url = (self._base_url + "/3/gallery/{}/{}/{}/{}?showViral="
"{}".format(section, sort, window, '{}', show_viral))
resp = self._send_request(url, limit=limit)
return [_get_album_or_image(thing, self) for thing in resp] |
<SYSTEM_TASK:>
Return the gallery album matching the id.
<END_TASK>
<USER_TASK:>
Description:
def get_gallery_album(self, id):
"""
Return the gallery album matching the id.
Note that an album's id is different from it's id as a gallery album.
This makes it possible to remove an album from the gallery and setting
it's privacy setting as secret, without compromising it's secrecy.
""" |
url = self._base_url + "/3/gallery/album/{0}".format(id)
resp = self._send_request(url)
return Gallery_album(resp, self) |
<SYSTEM_TASK:>
Return the gallery image matching the id.
<END_TASK>
<USER_TASK:>
Description:
def get_gallery_image(self, id):
"""
Return the gallery image matching the id.
Note that an image's id is different from it's id as a gallery image.
This makes it possible to remove an image from the gallery and setting
it's privacy setting as secret, without compromising it's secrecy.
""" |
url = self._base_url + "/3/gallery/image/{0}".format(id)
resp = self._send_request(url)
return Gallery_image(resp, self) |
<SYSTEM_TASK:>
Return a Image object representing the image with the given id.
<END_TASK>
<USER_TASK:>
Description:
def get_image(self, id):
"""Return a Image object representing the image with the given id.""" |
url = self._base_url + "/3/image/{0}".format(id)
resp = self._send_request(url)
return Image(resp, self) |
<SYSTEM_TASK:>
Return a Message object for given id.
<END_TASK>
<USER_TASK:>
Description:
def get_message(self, id):
"""
Return a Message object for given id.
:param id: The id of the message object to return.
""" |
url = self._base_url + "/3/message/{0}".format(id)
resp = self._send_request(url)
return Message(resp, self) |
<SYSTEM_TASK:>
Return the Gallery_image with the id submitted to subreddit gallery
<END_TASK>
<USER_TASK:>
Description:
def get_subreddit_image(self, subreddit, id):
"""
Return the Gallery_image with the id submitted to subreddit gallery
:param subreddit: The subreddit the image has been submitted to.
:param id: The id of the image we want.
""" |
url = self._base_url + "/3/gallery/r/{0}/{1}".format(subreddit, id)
resp = self._send_request(url)
return Gallery_image(resp, self) |
<SYSTEM_TASK:>
Return a User object for this username.
<END_TASK>
<USER_TASK:>
Description:
def get_user(self, username):
"""
Return a User object for this username.
:param username: The name of the user we want more information about.
""" |
url = self._base_url + "/3/account/{0}".format(username)
json = self._send_request(url)
return User(json, self) |
<SYSTEM_TASK:>
Refresh the access_token.
<END_TASK>
<USER_TASK:>
Description:
def refresh_access_token(self):
"""
Refresh the access_token.
The self.access_token attribute will be updated with the value of the
new access_token which will also be returned.
""" |
if self.client_secret is None:
raise Exception("client_secret must be set to execute "
"refresh_access_token.")
if self.refresh_token is None:
raise Exception("refresh_token must be set to execute "
"refresh_access_token.")
params = {'client_id': self.client_id,
'client_secret': self.client_secret,
'grant_type': 'refresh_token',
'refresh_token': self.refresh_token}
result = self._send_request(REFRESH_URL.format(self._base_url),
params=params, method='POST',
data_field=None)
self.access_token = result['access_token']
return self.access_token |
<SYSTEM_TASK:>
Search the gallery with the given query string.
<END_TASK>
<USER_TASK:>
Description:
def search_gallery(self, q):
"""Search the gallery with the given query string.""" |
url = self._base_url + "/3/gallery/search?q={0}".format(q)
resp = self._send_request(url)
return [_get_album_or_image(thing, self) for thing in resp] |
<SYSTEM_TASK:>
Upload the image at either path or url.
<END_TASK>
<USER_TASK:>
Description:
def upload_image(self, path=None, url=None, title=None, description=None,
album=None):
"""
Upload the image at either path or url.
:param path: The path to the image you want to upload.
:param url: The url to the image you want to upload.
:param title: The title the image will have when uploaded.
:param description: The description the image will have when uploaded.
:param album: The album the image will be added to when uploaded. Can
be either a Album object or it's id. Leave at None to upload
without adding to an Album, adding it later is possible.
Authentication as album owner is necessary to upload to an album
with this function.
:returns: An Image object representing the uploaded image.
""" |
if bool(path) == bool(url):
raise LookupError("Either path or url must be given.")
if path:
with open(path, 'rb') as image_file:
binary_data = image_file.read()
image = b64encode(binary_data)
else:
image = url
payload = {'album_id': album, 'image': image,
'title': title, 'description': description}
resp = self._send_request(self._base_url + "/3/image",
params=payload, method='POST')
# TEMPORARY HACK:
# On 5-08-2013 I noticed Imgur now returned enough information from
# this call to fully populate the Image object. However those variables
# that matched arguments were always None, even if they had been given.
# See https://groups.google.com/forum/#!topic/imgur/F3uVb55TMGo
resp['title'] = title
resp['description'] = description
if album is not None:
resp['album'] = (Album({'id': album}, self, False) if not
isinstance(album, Album) else album)
return Image(resp, self) |
<SYSTEM_TASK:>
Return the message thread this Message is in.
<END_TASK>
<USER_TASK:>
Description:
def get_thread(self):
"""Return the message thread this Message is in.""" |
url = (self._imgur._base_url + "/3/message/{0}/thread".format(
self.first_message.id))
resp = self._imgur._send_request(url)
return [Message(msg, self._imgur) for msg in resp] |
<SYSTEM_TASK:>
Reply to this message.
<END_TASK>
<USER_TASK:>
Description:
def reply(self, body):
"""
Reply to this message.
This is a convenience method calling User.send_message. See it for more
information on usage. Note that both recipient and reply_to are given
by using this convenience method.
:param body: The body of the message.
""" |
return self.author.send_message(body=body, reply_to=self.id) |
<SYSTEM_TASK:>
Update the settings for the user.
<END_TASK>
<USER_TASK:>
Description:
def change_settings(self, bio=None, public_images=None,
messaging_enabled=None, album_privacy=None,
accepted_gallery_terms=None):
"""
Update the settings for the user.
:param bio: A basic description filled out by the user, is displayed in
the gallery profile page.
:param public_images: Set the default privacy setting of the users
images. If True images are public, if False private.
:param messaging_enabled: Set to True to enable messaging.
:param album_privacy: The default privacy level of albums created by
the user. Can be public, hidden or secret.
:param accepted_gallery_terms: The user agreement to Imgur Gallery
terms. Necessary before the user can submit to the gallery.
""" |
# NOTE: album_privacy should maybe be renamed to default_privacy
# NOTE: public_images is a boolean, despite the documentation saying it
# is a string.
url = self._imgur._base_url + "/3/account/{0}/settings".format(self.name)
resp = self._imgur._send_request(url, needs_auth=True, params=locals(),
method='POST')
return resp |
<SYSTEM_TASK:>
Return a list of the user's albums.
<END_TASK>
<USER_TASK:>
Description:
def get_albums(self, limit=None):
"""
Return a list of the user's albums.
Secret and hidden albums are only returned if this is the logged-in
user.
""" |
url = (self._imgur._base_url + "/3/account/{0}/albums/{1}".format(self.name,
'{}'))
resp = self._imgur._send_request(url, limit=limit)
return [Album(alb, self._imgur, False) for alb in resp] |
<SYSTEM_TASK:>
Get a list of the images in the gallery this user has favorited.
<END_TASK>
<USER_TASK:>
Description:
def get_gallery_favorites(self):
"""Get a list of the images in the gallery this user has favorited.""" |
url = (self._imgur._base_url + "/3/account/{0}/gallery_favorites".format(
self.name))
resp = self._imgur._send_request(url)
return [Image(img, self._imgur) for img in resp] |
<SYSTEM_TASK:>
Has the user verified that the email he has given is legit?
<END_TASK>
<USER_TASK:>
Description:
def has_verified_email(self):
"""
Has the user verified that the email he has given is legit?
Verified e-mail is required to the gallery. Confirmation happens by
sending an email to the user and the owner of the email user verifying
that he is the same as the Imgur user.
""" |
url = (self._imgur._base_url + "/3/account/{0}/"
"verifyemail".format(self.name))
return self._imgur._send_request(url, needs_auth=True) |
<SYSTEM_TASK:>
Return all of the images associated with the user.
<END_TASK>
<USER_TASK:>
Description:
def get_images(self, limit=None):
"""Return all of the images associated with the user.""" |
url = (self._imgur._base_url + "/3/account/{0}/"
"images/{1}".format(self.name, '{}'))
resp = self._imgur._send_request(url, limit=limit)
return [Image(img, self._imgur) for img in resp] |
<SYSTEM_TASK:>
Return all messages sent to this user, formatted as a notification.
<END_TASK>
<USER_TASK:>
Description:
def get_messages(self, new=True):
"""
Return all messages sent to this user, formatted as a notification.
:param new: False for all notifications, True for only non-viewed
notifications.
""" |
url = (self._imgur._base_url + "/3/account/{0}/notifications/"
"messages".format(self.name))
result = self._imgur._send_request(url, params=locals(),
needs_auth=True)
return [Notification(msg_dict, self._imgur, has_fetched=True) for
msg_dict in result] |
<SYSTEM_TASK:>
Return all the notifications for this user.
<END_TASK>
<USER_TASK:>
Description:
def get_notifications(self, new=True):
"""Return all the notifications for this user.""" |
url = (self._imgur._base_url + "/3/account/{0}/"
"notifications".format(self.name))
resp = self._imgur._send_request(url, params=locals(), needs_auth=True)
msgs = [Message(msg_dict, self._imgur, has_fetched=True) for msg_dict
in resp['messages']]
replies = [Comment(com_dict, self._imgur, has_fetched=True) for
com_dict in resp['replies']]
return {'messages': msgs, 'replies': replies} |
<SYSTEM_TASK:>
Return all reply notifications for this user.
<END_TASK>
<USER_TASK:>
Description:
def get_replies(self, new=True):
"""
Return all reply notifications for this user.
:param new: False for all notifications, True for only non-viewed
notifications.
""" |
url = (self._imgur._base_url + "/3/account/{0}/"
"notifications/replies".format(self.name))
return self._imgur._send_request(url, needs_auth=True) |
<SYSTEM_TASK:>
Returns current settings.
<END_TASK>
<USER_TASK:>
Description:
def get_settings(self):
"""
Returns current settings.
Only accessible if authenticated as the user.
""" |
url = self._imgur._base_url + "/3/account/{0}/settings".format(self.name)
return self._imgur._send_request(url) |
<SYSTEM_TASK:>
Return a list of the images a user has submitted to the gallery.
<END_TASK>
<USER_TASK:>
Description:
def get_submissions(self, limit=None):
"""Return a list of the images a user has submitted to the gallery.""" |
url = (self._imgur._base_url + "/3/account/{0}/submissions/"
"{1}".format(self.name, '{}'))
resp = self._imgur._send_request(url, limit=limit)
return [_get_album_or_image(thing, self._imgur) for thing in resp] |
<SYSTEM_TASK:>
Send a message to this user from the logged in user.
<END_TASK>
<USER_TASK:>
Description:
def send_message(self, body, subject=None, reply_to=None):
"""
Send a message to this user from the logged in user.
:param body: The body of the message.
:param subject: The subject of the message. Note that if the this
message is a reply, then the subject of the first message will be
used instead.
:param reply_to: Messages can either be replies to other messages or
start a new message thread. If this is None it will start a new
message thread. If it's a Message object or message_id, then the
new message will be sent as a reply to the reply_to message.
""" |
url = self._imgur._base_url + "/3/message"
parent_id = reply_to.id if isinstance(reply_to, Message) else reply_to
payload = {'recipient': self.name, 'body': body, 'subject': subject,
'parent_id': parent_id}
self._imgur._send_request(url, params=payload, needs_auth=True,
method='POST') |
<SYSTEM_TASK:>
Send verification email to this users email address.
<END_TASK>
<USER_TASK:>
Description:
def send_verification_email(self):
"""
Send verification email to this users email address.
Remember that the verification email may end up in the users spam
folder.
""" |
url = (self._imgur._base_url + "/3/account/{0}"
"/verifyemail".format(self.name))
self._imgur._send_request(url, needs_auth=True, method='POST') |
<SYSTEM_TASK:>
Hook the current excepthook to the backtrace.
<END_TASK>
<USER_TASK:>
Description:
def hook(reverse=False,
align=False,
strip_path=False,
enable_on_envvar_only=False,
on_tty=False,
conservative=False,
styles=None,
tb=None,
tpe=None,
value=None):
"""Hook the current excepthook to the backtrace.
If `align` is True, all parts (line numbers, file names, etc..) will be
aligned to the left according to the longest entry.
If `strip_path` is True, only the file name will be shown, not its full
path.
If `enable_on_envvar_only` is True, only if the environment variable
`ENABLE_BACKTRACE` is set, backtrace will be activated.
If `on_tty` is True, backtrace will be activated only if you're running
in a readl terminal (i.e. not piped, redirected, etc..).
If `convervative` is True, the traceback will have more seemingly original
style (There will be no alignment by default, 'File', 'line' and 'in'
prefixes and will ignore any styling provided by the user.)
See https://github.com/nir0s/backtrace/blob/master/README.md for
information on `styles`.
""" |
if enable_on_envvar_only and 'ENABLE_BACKTRACE' not in os.environ:
return
isatty = getattr(sys.stderr, 'isatty', lambda: False)
if on_tty and not isatty():
return
if conservative:
styles = CONVERVATIVE_STYLES
align = align or False
elif styles:
for k in STYLES.keys():
styles[k] = styles.get(k, STYLES[k])
else:
styles = STYLES
# For Windows
colorama.init()
def backtrace_excepthook(tpe, value, tb=None):
# Don't know if we're getting traceback or traceback entries.
# We'll try to parse a traceback object.
try:
traceback_entries = traceback.extract_tb(tb)
except AttributeError:
traceback_entries = tb
parser = _Hook(traceback_entries, align, strip_path, conservative)
tpe = tpe if isinstance(tpe, str) else tpe.__name__
tb_message = styles['backtrace'].format('Traceback ({0}):'.format(
'Most recent call ' + ('first' if reverse else 'last'))) + \
Style.RESET_ALL
err_message = styles['error'].format(tpe + ': ' + str(value)) + \
Style.RESET_ALL
if reverse:
parser.reverse()
_flush(tb_message)
backtrace = parser.generate_backtrace(styles)
backtrace.insert(0 if reverse else len(backtrace), err_message)
for entry in backtrace:
_flush(entry)
if tb:
backtrace_excepthook(tpe=tpe, value=value, tb=tb)
else:
sys.excepthook = backtrace_excepthook |
<SYSTEM_TASK:>
Receive a list of strings representing the input from stdin and return
<END_TASK>
<USER_TASK:>
Description:
def _extract_traceback(text):
"""Receive a list of strings representing the input from stdin and return
the restructured backtrace.
This iterates over the output and once it identifies a hopefully genuine
identifier, it will start parsing output.
In the case the input includes a reraise (a Python 3 case), the primary
traceback isn't handled, only the reraise.
Each of the traceback lines are then handled two lines at a time for each
stack object.
Note that all parts of each stack object are stripped from newlines and
spaces to keep the output clean.
""" |
capture = False
entries = []
all_else = []
ignore_trace = False
# In python 3, a traceback may includes output from a reraise.
# e.g, an exception is captured and reraised with another exception.
# This marks that we should ignore
if text.count(TRACEBACK_IDENTIFIER) == 2:
ignore_trace = True
for index, line in enumerate(text):
if TRACEBACK_IDENTIFIER in line:
if ignore_trace:
ignore_trace = False
continue
capture = True
# We're not capturing and making sure we only read lines
# with spaces since, after the initial identifier, all traceback lines
# contain a prefix spacing.
elif capture and line.startswith(' '):
if index % 2 == 0:
# Line containing a file, line and module.
line = line.strip().strip('\n')
next_line = text[index + 1].strip('\n')
entries.append(line + ', ' + next_line)
elif capture:
# Line containing the module call.
entries.append(line)
break
else:
# Add everything else after the traceback.
all_else.append(line)
traceback_entries = []
# Build the traceback structure later passed for formatting.
for index, line in enumerate(entries[:-2]):
# TODO: This should be done in a _parse_entry function
element = line.split(',')
element[0] = element[0].strip().lstrip('File').strip(' "')
element[1] = element[1].strip().lstrip('line').strip()
element[2] = element[2].strip().lstrip('in').strip()
traceback_entries.append(tuple(element))
return traceback_entries, all_else |
<SYSTEM_TASK:>
Look at a list of sources and split them according to their class.
<END_TASK>
<USER_TASK:>
Description:
def classify_catalog(catalog):
"""
Look at a list of sources and split them according to their class.
Parameters
----------
catalog : iterable
A list or iterable object of {SimpleSource, IslandSource, OutputSource} objects, possibly mixed.
Any other objects will be silently ignored.
Returns
-------
components : list
List of sources of type OutputSource
islands : list
List of sources of type IslandSource
simples : list
List of source of type SimpleSource
""" |
components = []
islands = []
simples = []
for source in catalog:
if isinstance(source, OutputSource):
components.append(source)
elif isinstance(source, IslandSource):
islands.append(source)
elif isinstance(source, SimpleSource):
simples.append(source)
return components, islands, simples |
<SYSTEM_TASK:>
Iterate over a catalog of sources, and return an island worth of sources at a time.
<END_TASK>
<USER_TASK:>
Description:
def island_itergen(catalog):
"""
Iterate over a catalog of sources, and return an island worth of sources at a time.
Yields a list of components, one island at a time
Parameters
----------
catalog : iterable
A list or iterable of :class:`AegeanTools.models.OutputSource` objects.
Yields
------
group : list
A list of all sources within an island, one island at a time.
""" |
# reverse sort so that we can pop the last elements and get an increasing island number
catalog = sorted(catalog)
catalog.reverse()
group = []
# using pop and keeping track of the list length ourselves is faster than
# constantly asking for len(catalog)
src = catalog.pop()
c_len = len(catalog)
isle_num = src.island
while c_len >= 0:
if src.island == isle_num:
group.append(src)
c_len -= 1
if c_len <0:
# we have just added the last item from the catalog
# and there are no more to pop
yield group
else:
src = catalog.pop()
else:
isle_num += 1
# maybe there are no sources in this island so skip it
if group == []:
continue
yield group
group = []
return |
<SYSTEM_TASK:>
Convert attributes of type npumpy.float32 to numpy.float64 so that they will print properly.
<END_TASK>
<USER_TASK:>
Description:
def _sanitise(self):
"""
Convert attributes of type npumpy.float32 to numpy.float64 so that they will print properly.
""" |
for k in self.__dict__:
if isinstance(self.__dict__[k], np.float32): # np.float32 has a broken __str__ method
self.__dict__[k] = np.float64(self.__dict__[k]) |
<SYSTEM_TASK:>
Add one or more circles to this region
<END_TASK>
<USER_TASK:>
Description:
def add_circles(self, ra_cen, dec_cen, radius, depth=None):
"""
Add one or more circles to this region
Parameters
----------
ra_cen, dec_cen, radius : float or list
The center and radius of the circle or circles to add to this region.
depth : int
The depth at which the given circles will be inserted.
""" |
if depth is None or depth > self.maxdepth:
depth = self.maxdepth
try:
sky = list(zip(ra_cen, dec_cen))
rad = radius
except TypeError:
sky = [[ra_cen, dec_cen]]
rad = [radius]
sky = np.array(sky)
rad = np.array(rad)
vectors = self.sky2vec(sky)
for vec, r in zip(vectors, rad):
pix = hp.query_disc(2**depth, vec, r, inclusive=True, nest=True)
self.add_pixels(pix, depth)
self._renorm()
return |
<SYSTEM_TASK:>
Add a single polygon to this region.
<END_TASK>
<USER_TASK:>
Description:
def add_poly(self, positions, depth=None):
"""
Add a single polygon to this region.
Parameters
----------
positions : [[ra, dec], ...]
Positions for the vertices of the polygon. The polygon needs to be convex and non-intersecting.
depth : int
The deepth at which the polygon will be inserted.
""" |
if not (len(positions) >= 3): raise AssertionError("A minimum of three coordinate pairs are required")
if depth is None or depth > self.maxdepth:
depth = self.maxdepth
ras, decs = np.array(list(zip(*positions)))
sky = self.radec2sky(ras, decs)
pix = hp.query_polygon(2**depth, self.sky2vec(sky), inclusive=True, nest=True)
self.add_pixels(pix, depth)
self._renorm()
return |
<SYSTEM_TASK:>
Add one or more HEALPix pixels to this region.
<END_TASK>
<USER_TASK:>
Description:
def add_pixels(self, pix, depth):
"""
Add one or more HEALPix pixels to this region.
Parameters
----------
pix : int or iterable
The pixels to be added
depth : int
The depth at which the pixels are added.
""" |
if depth not in self.pixeldict:
self.pixeldict[depth] = set()
self.pixeldict[depth].update(set(pix)) |
<SYSTEM_TASK:>
Calculate the total area represented by this region.
<END_TASK>
<USER_TASK:>
Description:
def get_area(self, degrees=True):
"""
Calculate the total area represented by this region.
Parameters
----------
degrees : bool
If True then return the area in square degrees, otherwise use steradians.
Default = True.
Returns
-------
area : float
The area of the region.
""" |
area = 0
for d in range(1, self.maxdepth+1):
area += len(self.pixeldict[d])*hp.nside2pixarea(2**d, degrees=degrees)
return area |
<SYSTEM_TASK:>
Convert the multi-depth pixeldict into a single set of pixels at the deepest layer.
<END_TASK>
<USER_TASK:>
Description:
def _demote_all(self):
"""
Convert the multi-depth pixeldict into a single set of pixels at the deepest layer.
The result is cached, and reset when any changes are made to this region.
""" |
# only do the calculations if the demoted list is empty
if len(self.demoted) == 0:
pd = self.pixeldict
for d in range(1, self.maxdepth):
for p in pd[d]:
pd[d+1].update(set((4*p, 4*p+1, 4*p+2, 4*p+3)))
pd[d] = set() # clear the pixels from this level
self.demoted = pd[d+1]
return |
<SYSTEM_TASK:>
Remake the pixel dictionary, merging groups of pixels at level N into a single pixel
<END_TASK>
<USER_TASK:>
Description:
def _renorm(self):
"""
Remake the pixel dictionary, merging groups of pixels at level N into a single pixel
at level N-1
""" |
self.demoted = set()
# convert all to lowest level
self._demote_all()
# now promote as needed
for d in range(self.maxdepth, 2, -1):
plist = self.pixeldict[d].copy()
for p in plist:
if p % 4 == 0:
nset = set((p, p+1, p+2, p+3))
if p+1 in plist and p+2 in plist and p+3 in plist:
# remove the four pixels from this level
self.pixeldict[d].difference_update(nset)
# add a new pixel to the next level up
self.pixeldict[d-1].add(p/4)
self.demoted = set()
return |
<SYSTEM_TASK:>
Test whether a sky position is within this region
<END_TASK>
<USER_TASK:>
Description:
def sky_within(self, ra, dec, degin=False):
"""
Test whether a sky position is within this region
Parameters
----------
ra, dec : float
Sky position.
degin : bool
If True the ra/dec is interpreted as degrees, otherwise as radians.
Default = False.
Returns
-------
within : bool
True if the given position is within one of the region's pixels.
""" |
sky = self.radec2sky(ra, dec)
if degin:
sky = np.radians(sky)
theta_phi = self.sky2ang(sky)
# Set values that are nan to be zero and record a mask
mask = np.bitwise_not(np.logical_and.reduce(np.isfinite(theta_phi), axis=1))
theta_phi[mask, :] = 0
theta, phi = theta_phi.transpose()
pix = hp.ang2pix(2**self.maxdepth, theta, phi, nest=True)
pixelset = self.get_demoted()
result = np.in1d(pix, list(pixelset))
# apply the mask and set the shonky values to False
result[mask] = False
return result |
<SYSTEM_TASK:>
Add another Region by performing union on their pixlists.
<END_TASK>
<USER_TASK:>
Description:
def union(self, other, renorm=True):
"""
Add another Region by performing union on their pixlists.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
renorm : bool
Perform renormalisation after the operation?
Default = True.
""" |
# merge the pixels that are common to both
for d in range(1, min(self.maxdepth, other.maxdepth)+1):
self.add_pixels(other.pixeldict[d], d)
# if the other region is at higher resolution, then include a degraded version of the remaining pixels.
if self.maxdepth < other.maxdepth:
for d in range(self.maxdepth+1, other.maxdepth+1):
for p in other.pixeldict[d]:
# promote this pixel to self.maxdepth
pp = p/4**(d-self.maxdepth)
self.pixeldict[self.maxdepth].add(pp)
if renorm:
self._renorm()
return |
<SYSTEM_TASK:>
Subtract another Region by performing a difference operation on their pixlists.
<END_TASK>
<USER_TASK:>
Description:
def without(self, other):
"""
Subtract another Region by performing a difference operation on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
""" |
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].difference_update(opd)
self._renorm()
return |
<SYSTEM_TASK:>
Combine with another Region by performing intersection on their pixlists.
<END_TASK>
<USER_TASK:>
Description:
def intersect(self, other):
"""
Combine with another Region by performing intersection on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
""" |
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].intersection_update(opd)
self._renorm()
return |
<SYSTEM_TASK:>
Combine with another Region by performing the symmetric difference of their pixlists.
<END_TASK>
<USER_TASK:>
Description:
def symmetric_difference(self, other):
"""
Combine with another Region by performing the symmetric difference of their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
""" |
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].symmetric_difference_update(opd)
self._renorm()
return |
<SYSTEM_TASK:>
Write a ds9 region file that represents this region as a set of diamonds.
<END_TASK>
<USER_TASK:>
Description:
def write_reg(self, filename):
"""
Write a ds9 region file that represents this region as a set of diamonds.
Parameters
----------
filename : str
File to write
""" |
with open(filename, 'w') as out:
for d in range(1, self.maxdepth+1):
for p in self.pixeldict[d]:
line = "fk5; polygon("
# the following int() gets around some problems with np.int64 that exist prior to numpy v 1.8.1
vectors = list(zip(*hp.boundaries(2**d, int(p), step=1, nest=True)))
positions = []
for sky in self.vec2sky(np.array(vectors), degrees=True):
ra, dec = sky
pos = SkyCoord(ra/15, dec, unit=(u.degree, u.degree))
positions.append(pos.ra.to_string(sep=':', precision=2))
positions.append(pos.dec.to_string(sep=':', precision=2))
line += ','.join(positions)
line += ")"
print(line, file=out)
return |
<SYSTEM_TASK:>
Write a fits file representing the MOC of this region.
<END_TASK>
<USER_TASK:>
Description:
def write_fits(self, filename, moctool=''):
"""
Write a fits file representing the MOC of this region.
Parameters
----------
filename : str
File to write
moctool : str
String to be written to fits header with key "MOCTOOL".
Default = ''
""" |
datafile = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'MOC.fits')
hdulist = fits.open(datafile)
cols = fits.Column(name='NPIX', array=self._uniq(), format='1K')
tbhdu = fits.BinTableHDU.from_columns([cols])
hdulist[1] = tbhdu
hdulist[1].header['PIXTYPE'] = ('HEALPIX ', 'HEALPix magic code')
hdulist[1].header['ORDERING'] = ('NUNIQ ', 'NUNIQ coding method')
hdulist[1].header['COORDSYS'] = ('C ', 'ICRS reference frame')
hdulist[1].header['MOCORDER'] = (self.maxdepth, 'MOC resolution (best order)')
hdulist[1].header['MOCTOOL'] = (moctool, 'Name of the MOC generator')
hdulist[1].header['MOCTYPE'] = ('CATALOG', 'Source type (IMAGE or CATALOG)')
hdulist[1].header['MOCID'] = (' ', 'Identifier of the collection')
hdulist[1].header['ORIGIN'] = (' ', 'MOC origin')
time = datetime.datetime.utcnow()
hdulist[1].header['DATE'] = (datetime.datetime.strftime(time, format="%Y-%m-%dT%H:%m:%SZ"), 'MOC creation date')
hdulist.writeto(filename, overwrite=True)
return |
<SYSTEM_TASK:>
Create a list of all the pixels that cover this region.
<END_TASK>
<USER_TASK:>
Description:
def _uniq(self):
"""
Create a list of all the pixels that cover this region.
This list contains overlapping pixels of different orders.
Returns
-------
pix : list
A list of HEALPix pixel numbers.
""" |
pd = []
for d in range(1, self.maxdepth):
pd.extend(map(lambda x: int(4**(d+1) + x), self.pixeldict[d]))
return sorted(pd) |
<SYSTEM_TASK:>
Convert sky positions in to 3d-vectors on the unit sphere.
<END_TASK>
<USER_TASK:>
Description:
def sky2vec(cls, sky):
"""
Convert sky positions in to 3d-vectors on the unit sphere.
Parameters
----------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
Returns
-------
vec : numpy.array
Unit vectors as an array of (x,y,z)
See Also
--------
:func:`AegeanTools.regions.Region.vec2sky`
""" |
theta_phi = cls.sky2ang(sky)
theta, phi = map(np.array, list(zip(*theta_phi)))
vec = hp.ang2vec(theta, phi)
return vec |
<SYSTEM_TASK:>
Create a new WCSHelper class from the given header.
<END_TASK>
<USER_TASK:>
Description:
def from_header(cls, header, beam=None, lat=None):
"""
Create a new WCSHelper class from the given header.
Parameters
----------
header : `astropy.fits.HDUHeader` or string
The header to be used to create the WCS helper
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
lat : float
The latitude of the telescope.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object.
""" |
try:
wcs = pywcs.WCS(header, naxis=2)
except: # TODO: figure out what error is being thrown
wcs = pywcs.WCS(str(header), naxis=2)
if beam is None:
beam = get_beam(header)
else:
beam = beam
if beam is None:
logging.critical("Cannot determine beam information")
_, pixscale = get_pixinfo(header)
refpix = (header['CRPIX1'], header['CRPIX2'])
return cls(wcs, beam, pixscale, refpix, lat) |
<SYSTEM_TASK:>
Create a new WCSHelper class from a given fits file.
<END_TASK>
<USER_TASK:>
Description:
def from_file(cls, filename, beam=None):
"""
Create a new WCSHelper class from a given fits file.
Parameters
----------
filename : string
The file to be read
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object
""" |
header = fits.getheader(filename)
return cls.from_header(header, beam) |
<SYSTEM_TASK:>
Convert pixel coordinates into sky coordinates.
<END_TASK>
<USER_TASK:>
Description:
def pix2sky(self, pixel):
"""
Convert pixel coordinates into sky coordinates.
Parameters
----------
pixel : (float, float)
The (x,y) pixel coordinates
Returns
-------
sky : (float, float)
The (ra,dec) sky coordinates in degrees
""" |
x, y = pixel
# wcs and pyfits have oposite ideas of x/y
return self.wcs.wcs_pix2world([[y, x]], 1)[0] |
<SYSTEM_TASK:>
Convert sky coordinates into pixel coordinates.
<END_TASK>
<USER_TASK:>
Description:
def sky2pix(self, pos):
"""
Convert sky coordinates into pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) sky coordinates (degrees)
Returns
-------
pixel : (float, float)
The (x,y) pixel coordinates
""" |
pixel = self.wcs.wcs_world2pix([pos], 1)
# wcs and pyfits have oposite ideas of x/y
return [pixel[0][1], pixel[0][0]] |
<SYSTEM_TASK:>
Convert a vector from sky to pixel coords.
<END_TASK>
<USER_TASK:>
Description:
def sky2pix_vec(self, pos, r, pa):
"""
Convert a vector from sky to pixel coords.
The vector has a magnitude, angle, and an origin on the sky.
Parameters
----------
pos : (float, float)
The (ra, dec) of the origin of the vector (degrees).
r : float
The magnitude or length of the vector (degrees).
pa : float
The position angle of the vector (degrees).
Returns
-------
x, y : float
The pixel coordinates of the origin.
r, theta : float
The magnitude (pixels) and angle (degrees) of the vector.
""" |
ra, dec = pos
x, y = self.sky2pix(pos)
a = translate(ra, dec, r, pa)
locations = self.sky2pix(a)
x_off, y_off = locations
a = np.sqrt((x - x_off) ** 2 + (y - y_off) ** 2)
theta = np.degrees(np.arctan2((y_off - y), (x_off - x)))
return x, y, a, theta |
<SYSTEM_TASK:>
Given and input position and vector in pixel coordinates, calculate
<END_TASK>
<USER_TASK:>
Description:
def pix2sky_vec(self, pixel, r, theta):
"""
Given and input position and vector in pixel coordinates, calculate
the equivalent position and vector in sky coordinates.
Parameters
----------
pixel : (int,int)
origin of vector in pixel coordinates
r : float
magnitude of vector in pixels
theta : float
angle of vector in degrees
Returns
-------
ra, dec : float
The (ra, dec) of the origin point (degrees).
r, pa : float
The magnitude and position angle of the vector (degrees).
""" |
ra1, dec1 = self.pix2sky(pixel)
x, y = pixel
a = [x + r * np.cos(np.radians(theta)),
y + r * np.sin(np.radians(theta))]
locations = self.pix2sky(a)
ra2, dec2 = locations
a = gcd(ra1, dec1, ra2, dec2)
pa = bear(ra1, dec1, ra2, dec2)
return ra1, dec1, a, pa |
<SYSTEM_TASK:>
Convert an ellipse from sky to pixel coordinates.
<END_TASK>
<USER_TASK:>
Description:
def sky2pix_ellipse(self, pos, a, b, pa):
"""
Convert an ellipse from sky to pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) of the ellipse center (degrees).
a, b, pa: float
The semi-major axis, semi-minor axis and position angle of the ellipse (degrees).
Returns
-------
x,y : float
The (x, y) pixel coordinates of the ellipse center.
sx, sy : float
The major and minor axes (FWHM) in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
""" |
ra, dec = pos
x, y = self.sky2pix(pos)
x_off, y_off = self.sky2pix(translate(ra, dec, a, pa))
sx = np.hypot((x - x_off), (y - y_off))
theta = np.arctan2((y_off - y), (x_off - x))
x_off, y_off = self.sky2pix(translate(ra, dec, b, pa - 90))
sy = np.hypot((x - x_off), (y - y_off))
theta2 = np.arctan2((y_off - y), (x_off - x)) - np.pi / 2
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = theta - theta2
sy *= abs(np.cos(defect))
return x, y, sx, sy, np.degrees(theta) |
<SYSTEM_TASK:>
Convert an ellipse from pixel to sky coordinates.
<END_TASK>
<USER_TASK:>
Description:
def pix2sky_ellipse(self, pixel, sx, sy, theta):
"""
Convert an ellipse from pixel to sky coordinates.
Parameters
----------
pixel : (float, float)
The (x, y) coordinates of the center of the ellipse.
sx, sy : float
The major and minor axes (FHWM) of the ellipse, in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
Returns
-------
ra, dec : float
The (ra, dec) coordinates of the center of the ellipse (degrees).
a, b : float
The semi-major and semi-minor axis of the ellipse (degrees).
pa : float
The position angle of the ellipse (degrees).
""" |
ra, dec = self.pix2sky(pixel)
x, y = pixel
v_sx = [x + sx * np.cos(np.radians(theta)),
y + sx * np.sin(np.radians(theta))]
ra2, dec2 = self.pix2sky(v_sx)
major = gcd(ra, dec, ra2, dec2)
pa = bear(ra, dec, ra2, dec2)
v_sy = [x + sy * np.cos(np.radians(theta - 90)),
y + sy * np.sin(np.radians(theta - 90))]
ra2, dec2 = self.pix2sky(v_sy)
minor = gcd(ra, dec, ra2, dec2)
pa2 = bear(ra, dec, ra2, dec2) - 90
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = pa - pa2
minor *= abs(np.cos(np.radians(defect)))
return ra, dec, major, minor, pa |
<SYSTEM_TASK:>
Determine the beam in pixels at the given location in pixel coordinates.
<END_TASK>
<USER_TASK:>
Description:
def get_pixbeam_pixel(self, x, y):
"""
Determine the beam in pixels at the given location in pixel coordinates.
Parameters
----------
x , y : float
The pixel coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
""" |
ra, dec = self.pix2sky((x, y))
return self.get_pixbeam(ra, dec) |
<SYSTEM_TASK:>
Determine the beam at the given sky location.
<END_TASK>
<USER_TASK:>
Description:
def get_beam(self, ra, dec):
"""
Determine the beam at the given sky location.
Parameters
----------
ra, dec : float
The sky coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in sky coordinates
""" |
# check to see if we need to scale the major axis based on the declination
if self.lat is None:
factor = 1
else:
# this works if the pa is zero. For non-zero pa it's a little more difficult
factor = np.cos(np.radians(dec - self.lat))
return Beam(self.beam.a / factor, self.beam.b, self.beam.pa) |
<SYSTEM_TASK:>
Determine the beam in pixels at the given location in sky coordinates.
<END_TASK>
<USER_TASK:>
Description:
def get_pixbeam(self, ra, dec):
"""
Determine the beam in pixels at the given location in sky coordinates.
Parameters
----------
ra , dec : float
The sly coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
""" |
if ra is None:
ra, dec = self.pix2sky(self.refpix)
pos = [ra, dec]
beam = self.get_beam(ra, dec)
_, _, major, minor, theta = self.sky2pix_ellipse(pos, beam.a, beam.b, beam.pa)
if major < minor:
major, minor = minor, major
theta -= 90
if theta < -180:
theta += 180
if not np.isfinite(theta):
theta = 0
if not all(np.isfinite([major, minor, theta])):
beam = None
else:
beam = Beam(major, minor, theta)
return beam |
<SYSTEM_TASK:>
Calculate the area of the synthesized beam in square degrees.
<END_TASK>
<USER_TASK:>
Description:
def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the synthesized beam in square degrees.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made.
Returns
-------
area : float
The beam area in square degrees.
""" |
barea = abs(self.beam.a * self.beam.b * np.pi) # in deg**2 at reference coords
if self.lat is not None:
barea /= np.cos(np.radians(dec - self.lat))
return barea |
<SYSTEM_TASK:>
Calculate the beam area in square pixels.
<END_TASK>
<USER_TASK:>
Description:
def get_beamarea_pix(self, ra, dec):
"""
Calculate the beam area in square pixels.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made
dec
Returns
-------
area : float
The beam area in square pixels.
""" |
parea = abs(self.pixscale[0] * self.pixscale[1]) # in deg**2 at reference coords
barea = self.get_beamarea_deg2(ra, dec)
return barea / parea |
<SYSTEM_TASK:>
Determine the local psf at a given sky location.
<END_TASK>
<USER_TASK:>
Description:
def get_psf_sky(self, ra, dec):
"""
Determine the local psf at a given sky location.
The psf is returned in degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis, semi-minor axis, and position angle in (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
""" |
# If we don't have a psf map then we just fall back to using the beam
# from the fits header (including ZA scaling)
if self.data is None:
beam = self.wcshelper.get_beam(ra, dec)
return beam.a, beam.b, beam.pa
x, y = self.sky2pix([ra, dec])
# We leave the interpolation in the hands of whoever is making these images
# clamping the x,y coords at the image boundaries just makes sense
x = int(np.clip(x, 0, self.data.shape[1] - 1))
y = int(np.clip(y, 0, self.data.shape[2] - 1))
psf_sky = self.data[:, x, y]
return psf_sky |
<SYSTEM_TASK:>
Get the psf at the location specified in pixel coordinates.
<END_TASK>
<USER_TASK:>
Description:
def get_pixbeam(self, ra, dec):
"""
Get the psf at the location specified in pixel coordinates.
The psf is also in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
""" |
# If there is no psf image then just use the fits header (plus lat scaling) from the wcshelper
if self.data is None:
return self.wcshelper.get_pixbeam(ra, dec)
# get the beam from the psf image data
psf = self.get_psf_pix(ra, dec)
if not np.all(np.isfinite(psf)):
log.warn("PSF requested, returned Null")
return None
return Beam(psf[0], psf[1], psf[2]) |
<SYSTEM_TASK:>
Calculate the area of the beam in square pixels.
<END_TASK>
<USER_TASK:>
Description:
def get_beamarea_pix(self, ra, dec):
"""
Calculate the area of the beam in square pixels.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square pixels.
""" |
beam = self.get_pixbeam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi |
<SYSTEM_TASK:>
Calculate the area of the beam in square degrees.
<END_TASK>
<USER_TASK:>
Description:
def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the beam in square degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square degrees.
""" |
beam = self.get_beam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi |
<SYSTEM_TASK:>
Find the first location in our array that is not empty
<END_TASK>
<USER_TASK:>
Description:
def find_start_point(self):
"""
Find the first location in our array that is not empty
""" |
for i, row in enumerate(self.data):
for j, _ in enumerate(row):
if self.data[i, j] != 0: # or not np.isfinite(self.data[i,j]):
return i, j |
<SYSTEM_TASK:>
Move from the current location to the next
<END_TASK>
<USER_TASK:>
Description:
def step(self, x, y):
"""
Move from the current location to the next
Parameters
----------
x, y : int
The current location
""" |
up_left = self.solid(x - 1, y - 1)
up_right = self.solid(x, y - 1)
down_left = self.solid(x - 1, y)
down_right = self.solid(x, y)
state = 0
self.prev = self.next
# which cells are filled?
if up_left:
state |= 1
if up_right:
state |= 2
if down_left:
state |= 4
if down_right:
state |= 8
# what is the next step?
if state in [1, 5, 13]:
self.next = self.UP
elif state in [2, 3, 7]:
self.next = self.RIGHT
elif state in [4, 12, 14]:
self.next = self.LEFT
elif state in [8, 10, 11]:
self.next = self.DOWN
elif state == 6:
if self.prev == self.UP:
self.next = self.LEFT
else:
self.next = self.RIGHT
elif state == 9:
if self.prev == self.RIGHT:
self.next = self.UP
else:
self.next = self.DOWN
else:
self.next = self.NOWHERE
return |
<SYSTEM_TASK:>
Determine whether the pixel x,y is nonzero
<END_TASK>
<USER_TASK:>
Description:
def solid(self, x, y):
"""
Determine whether the pixel x,y is nonzero
Parameters
----------
x, y : int
The pixel of interest.
Returns
-------
solid : bool
True if the pixel is not zero.
""" |
if not(0 <= x < self.xsize) or not(0 <= y < self.ysize):
return False
if self.data[x, y] == 0:
return False
return True |
<SYSTEM_TASK:>
Starting at a point on the perimeter of a region, 'walk' the perimeter to return
<END_TASK>
<USER_TASK:>
Description:
def walk_perimeter(self, startx, starty):
"""
Starting at a point on the perimeter of a region, 'walk' the perimeter to return
to the starting point. Record the path taken.
Parameters
----------
startx, starty : int
The starting location. Assumed to be on the perimeter of a region.
Returns
-------
perimeter : list
A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region.
""" |
# checks
startx = max(startx, 0)
startx = min(startx, self.xsize)
starty = max(starty, 0)
starty = min(starty, self.ysize)
points = []
x, y = startx, starty
while True:
self.step(x, y)
if 0 <= x <= self.xsize and 0 <= y <= self.ysize:
points.append((x, y))
if self.next == self.UP:
y -= 1
elif self.next == self.LEFT:
x -= 1
elif self.next == self.DOWN:
y += 1
elif self.next == self.RIGHT:
x += 1
# stop if we meet some kind of error
elif self.next == self.NOWHERE:
break
# stop when we return to the starting location
if x == startx and y == starty:
break
return points |
<SYSTEM_TASK:>
March about and trace the outline of our object
<END_TASK>
<USER_TASK:>
Description:
def do_march(self):
"""
March about and trace the outline of our object
Returns
-------
perimeter : list
The pixels on the perimeter of the region [[x1, y1], ...]
""" |
x, y = self.find_start_point()
perimeter = self.walk_perimeter(x, y)
return perimeter |
<SYSTEM_TASK:>
Blank all the pixels within the given perimeter.
<END_TASK>
<USER_TASK:>
Description:
def _blank_within(self, perimeter):
"""
Blank all the pixels within the given perimeter.
Parameters
----------
perimeter : list
The perimeter of the region.
""" |
# Method:
# scan around the perimeter filling 'up' from each pixel
# stopping when we reach the other boundary
for p in perimeter:
# if we are on the edge of the data then there is nothing to fill
if p[0] >= self.data.shape[0] or p[1] >= self.data.shape[1]:
continue
# if this pixel is blank then don't fill
if self.data[p] == 0:
continue
# blank this pixel
self.data[p] = 0
# blank until we reach the other perimeter
for i in range(p[1]+1, self.data.shape[1]):
q = p[0], i
# stop when we reach another part of the perimeter
if q in perimeter:
break
# fill everything in between, even inclusions
self.data[q] = 0
return |
<SYSTEM_TASK:>
Recursive march in the case that we have a fragmented shape.
<END_TASK>
<USER_TASK:>
Description:
def do_march_all(self):
"""
Recursive march in the case that we have a fragmented shape.
Returns
-------
perimeters : [perimeter1, ...]
The perimeters of all the regions in the image.
See Also
--------
:func:`AegeanTools.msq2.MarchingSquares.do_march`
""" |
# copy the data since we are going to be modifying it
data_copy = copy(self.data)
# iterate through finding an island, creating a perimeter,
# and then blanking the island
perimeters = []
p = self.find_start_point()
while p is not None:
x, y = p
perim = self.walk_perimeter(x, y)
perimeters.append(perim)
self._blank_within(perim)
p = self.find_start_point()
# restore the data
self.data = data_copy
return perimeters |
<SYSTEM_TASK:>
Generate a model 2d Gaussian with the given parameters.
<END_TASK>
<USER_TASK:>
Description:
def elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta):
"""
Generate a model 2d Gaussian with the given parameters.
Evaluate this model at the given locations x,y.
Parameters
----------
x, y : numeric or array-like
locations at which to evaluate the gaussian
amp : float
Peak value.
xo, yo : float
Center of the gaussian.
sx, sy : float
major/minor axes in sigmas
theta : float
position angle (degrees) CCW from x-axis
Returns
-------
data : numeric or array-like
Gaussian function evaluated at the x,y locations.
""" |
try:
sint, cost = math.sin(np.radians(theta)), math.cos(np.radians(theta))
except ValueError as e:
if 'math domain error' in e.args:
sint, cost = np.nan, np.nan
xxo = x - xo
yyo = y - yo
exp = (xxo * cost + yyo * sint) ** 2 / sx ** 2 \
+ (xxo * sint - yyo * cost) ** 2 / sy ** 2
exp *= -1. / 2
return amp * np.exp(exp) |
<SYSTEM_TASK:>
Construct a correlation matrix corresponding to the data.
<END_TASK>
<USER_TASK:>
Description:
def Cmatrix(x, y, sx, sy, theta):
"""
Construct a correlation matrix corresponding to the data.
The matrix assumes a gaussian correlation function.
Parameters
----------
x, y : array-like
locations at which to evaluate the correlation matirx
sx, sy : float
major/minor axes of the gaussian correlation function (sigmas)
theta : float
position angle of the gaussian correlation function (degrees)
Returns
-------
data : array-like
The C-matrix.
""" |
C = np.vstack([elliptical_gaussian(x, y, 1, i, j, sx, sy, theta) for i, j in zip(x, y)])
return C |
<SYSTEM_TASK:>
Calculate a matrix which is effectively the square root of the correlation matrix C
<END_TASK>
<USER_TASK:>
Description:
def Bmatrix(C):
"""
Calculate a matrix which is effectively the square root of the correlation matrix C
Parameters
----------
C : 2d array
A covariance matrix
Returns
-------
B : 2d array
A matrix B such the B.dot(B') = inv(C)
""" |
# this version of finding the square root of the inverse matrix
# suggested by Cath Trott
L, Q = eigh(C)
# force very small eigenvalues to have some minimum non-zero value
minL = 1e-9*L[-1]
L[L < minL] = minL
S = np.diag(1 / np.sqrt(L))
B = Q.dot(S)
return B |
<SYSTEM_TASK:>
Calculate the autocorrelation function of the noise
<END_TASK>
<USER_TASK:>
Description:
def nan_acf(noise):
"""
Calculate the autocorrelation function of the noise
where the noise is a 2d array that may contain nans
Parameters
----------
noise : 2d-array
Noise image.
Returns
-------
acf : 2d-array
The ACF.
""" |
corr = np.zeros(noise.shape)
ix,jx = noise.shape
for i in range(ix):
si_min = slice(i, None, None)
si_max = slice(None, ix-i, None)
for j in range(jx):
sj_min = slice(j, None, None)
sj_max = slice(None, jx-j, None)
if np.all(np.isnan(noise[si_min, sj_min])) or np.all(np.isnan(noise[si_max, sj_max])):
corr[i, j] = np.nan
else:
corr[i, j] = np.nansum(noise[si_min, sj_min] * noise[si_max, sj_max])
# return the normalised acf
return corr / np.nanmax(corr) |
<SYSTEM_TASK:>
Calculate and apply a bias correction to the given fit parameters
<END_TASK>
<USER_TASK:>
Description:
def bias_correct(params, data, acf=None):
"""
Calculate and apply a bias correction to the given fit parameters
Parameters
----------
params : lmfit.Parameters
The model parameters. These will be modified.
data : 2d-array
The data which was used in the fitting
acf : 2d-array
ACF of the data. Default = None.
Returns
-------
None
See Also
--------
:func:`AegeanTools.fitting.RB_bias`
""" |
bias = RB_bias(data, params, acf=acf)
i = 0
for p in params:
if 'theta' in p:
continue
if params[p].vary:
params[p].value -= bias[i]
i += 1
return |
<SYSTEM_TASK:>
Convert an lmfit.Parameters object into a function which calculates the model.
<END_TASK>
<USER_TASK:>
Description:
def ntwodgaussian_lmfit(params):
"""
Convert an lmfit.Parameters object into a function which calculates the model.
Parameters
----------
params : lmfit.Parameters
Model parameters, can have multiple components.
Returns
-------
model : func
A function f(x,y) that will compute the model.
""" |
def rfunc(x, y):
"""
Compute the model given by params, at pixel coordinates x,y
Parameters
----------
x, y : numpy.ndarray
The x/y pixel coordinates at which the model is being evaluated
Returns
-------
result : numpy.ndarray
Model
"""
result = None
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
# I hope this doesn't kill our run time
amp = np.nan_to_num(params[prefix + 'amp'].value)
xo = params[prefix + 'xo'].value
yo = params[prefix + 'yo'].value
sx = params[prefix + 'sx'].value
sy = params[prefix + 'sy'].value
theta = params[prefix + 'theta'].value
if result is not None:
result += elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
else:
result = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
return result
return rfunc |
<SYSTEM_TASK:>
Fit the model to the data
<END_TASK>
<USER_TASK:>
Description:
def do_lmfit(data, params, B=None, errs=None, dojac=True):
"""
Fit the model to the data
data may contain 'flagged' or 'masked' data with the value of np.NaN
Parameters
----------
data : 2d-array
Image data
params : lmfit.Parameters
Initial model guess.
B : 2d-array
B matrix to be used in residual calculations.
Default = None.
errs : 1d-array
dojac : bool
If true then an analytic jacobian will be passed to the fitting routine.
Returns
-------
result : ?
lmfit.minimize result.
params : lmfit.Params
Fitted model.
See Also
--------
:func:`AegeanTools.fitting.lmfit_jacobian`
""" |
# copy the params so as not to change the initial conditions
# in case we want to use them elsewhere
params = copy.deepcopy(params)
data = np.array(data)
mask = np.where(np.isfinite(data))
def residual(params, **kwargs):
"""
The residual function required by lmfit
Parameters
----------
params: lmfit.Params
The parameters of the model being fit
Returns
-------
result : numpy.ndarray
Model - Data
"""
f = ntwodgaussian_lmfit(params) # A function describing the model
model = f(*mask) # The actual model
if B is None:
return model - data[mask]
else:
return (model - data[mask]).dot(B)
if dojac:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs}, Dfun=lmfit_jacobian)
else:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs})
# Remake the residual so that it is once again (model - data)
if B is not None:
result.residual = result.residual.dot(inv(B))
return result, params |
<SYSTEM_TASK:>
Take a set of parameters that were fit with lmfit, and replace the errors
<END_TASK>
<USER_TASK:>
Description:
def covar_errors(params, data, errs, B, C=None):
"""
Take a set of parameters that were fit with lmfit, and replace the errors
with the 1\sigma errors calculated using the covariance matrix.
Parameters
----------
params : lmfit.Parameters
Model
data : 2d-array
Image data
errs : 2d-array ?
Image noise.
B : 2d-array
B matrix.
C : 2d-array
C matrix. Optional. If supplied then Bmatrix will not be used.
Returns
-------
params : lmfit.Parameters
Modified model.
""" |
mask = np.where(np.isfinite(data))
# calculate the proper parameter errors and copy them across.
if C is not None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], errs=errs)
covar = np.transpose(J).dot(inv(C)).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
C = None
if C is None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], B=B, errs=errs)
covar = np.transpose(J).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
onesigma = [-2] * len(mask[0])
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
j = 0
for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']:
if params[prefix + p].vary:
params[prefix + p].stderr = onesigma[j]
j += 1
return params |
<SYSTEM_TASK:>
act as a multiprocessing barrier
<END_TASK>
<USER_TASK:>
Description:
def barrier(events, sid, kind='neighbour'):
"""
act as a multiprocessing barrier
""" |
events[sid].set()
# only wait for the neighbours
if kind=='neighbour':
if sid > 0:
logging.debug("{0} is waiting for {1}".format(sid, sid - 1))
events[sid - 1].wait()
if sid < len(bkg_events) - 1:
logging.debug("{0} is waiting for {1}".format(sid, sid + 1))
events[sid + 1].wait()
# wait for all
else:
[e.wait() for e in events]
return |
<SYSTEM_TASK:>
Perform sigma clipping on an array, ignoring non finite values.
<END_TASK>
<USER_TASK:>
Description:
def sigmaclip(arr, lo, hi, reps=3):
"""
Perform sigma clipping on an array, ignoring non finite values.
During each iteration return an array whose elements c obey:
mean -std*lo < c < mean + std*hi
where mean/std are the mean std of the input array.
Parameters
----------
arr : iterable
An iterable array of numeric types.
lo : float
The negative clipping level.
hi : float
The positive clipping level.
reps : int
The number of iterations to perform.
Default = 3.
Returns
-------
mean : float
The mean of the array, possibly nan
std : float
The std of the array, possibly nan
Notes
-----
Scipy v0.16 now contains a comparable method that will ignore nan/inf values.
""" |
clipped = np.array(arr)[np.isfinite(arr)]
if len(clipped) < 1:
return np.nan, np.nan
std = np.std(clipped)
mean = np.mean(clipped)
for _ in range(int(reps)):
clipped = clipped[np.where(clipped > mean-std*lo)]
clipped = clipped[np.where(clipped < mean+std*hi)]
pstd = std
if len(clipped) < 1:
break
std = np.std(clipped)
mean = np.mean(clipped)
if 2*abs(pstd-std)/(pstd+std) < 0.2:
break
return mean, std |
<SYSTEM_TASK:>
A shallow wrapper for sigma_filter.
<END_TASK>
<USER_TASK:>
Description:
def _sf2(args):
"""
A shallow wrapper for sigma_filter.
Parameters
----------
args : list
A list of arguments for sigma_filter
Returns
-------
None
""" |
# an easier to debug traceback when multiprocessing
# thanks to https://stackoverflow.com/a/16618842/1710603
try:
return sigma_filter(*args)
except:
import traceback
raise Exception("".join(traceback.format_exception(*sys.exc_info()))) |
<SYSTEM_TASK:>
Calculate the background and noise images corresponding to the input file.
<END_TASK>
<USER_TASK:>
Description:
def filter_mc_sharemem(filename, step_size, box_size, cores, shape, nslice=None, domask=True):
"""
Calculate the background and noise images corresponding to the input file.
The calculation is done via a box-car approach and uses multiple cores and shared memory.
Parameters
----------
filename : str
Filename to be filtered.
step_size : (int, int)
Step size for the filter.
box_size : (int, int)
Box size for the filter.
cores : int
Number of cores to use. If None then use all available.
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
shape : (int, int)
The shape of the image in the given file.
domask : bool
True(Default) = copy data mask to output.
Returns
-------
bkg, rms : numpy.ndarray
The interpolated background and noise images.
""" |
if cores is None:
cores = multiprocessing.cpu_count()
if (nslice is None) or (cores==1):
nslice = cores
img_y, img_x = shape
# initialise some shared memory
global ibkg
# bkg = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
# ibkg = multiprocessing.sharedctypes.Array(bkg._type_, bkg, lock=True)
ibkg = multiprocessing.Array('f', img_y*img_x)
global irms
#rms = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
#irms = multiprocessing.sharedctypes.Array(rms._type_, rms, lock=True)
irms = multiprocessing.Array('f', img_y * img_x)
logging.info("using {0} cores".format(cores))
logging.info("using {0} stripes".format(nslice))
if nslice > 1:
# box widths should be multiples of the step_size, and not zero
width_y = int(max(img_y/nslice/step_size[1], 1) * step_size[1])
# locations of the box edges
ymins = list(range(0, img_y, width_y))
ymaxs = list(range(width_y, img_y, width_y))
ymaxs.append(img_y)
else:
ymins = [0]
ymaxs = [img_y]
logging.debug("ymins {0}".format(ymins))
logging.debug("ymaxs {0}".format(ymaxs))
# create an event per stripe
global bkg_events, mask_events
bkg_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
mask_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
args = []
for i, region in enumerate(zip(ymins, ymaxs)):
args.append((filename, region, step_size, box_size, shape, domask, i))
# start a new process for each task, hopefully to reduce residual memory use
pool = multiprocessing.Pool(processes=cores, maxtasksperchild=1)
try:
# chunksize=1 ensures that we only send a single task to each process
pool.map_async(_sf2, args, chunksize=1).get(timeout=10000000)
except KeyboardInterrupt:
logging.error("Caught keyboard interrupt")
pool.close()
sys.exit(1)
pool.close()
pool.join()
bkg = np.reshape(np.array(ibkg[:], dtype=np.float32), shape)
rms = np.reshape(np.array(irms[:], dtype=np.float32), shape)
del ibkg, irms
return bkg, rms |
<SYSTEM_TASK:>
Combine data and a fits header to write a fits file.
<END_TASK>
<USER_TASK:>
Description:
def write_fits(data, header, file_name):
"""
Combine data and a fits header to write a fits file.
Parameters
----------
data : numpy.ndarray
The data to be written.
header : astropy.io.fits.hduheader
The header for the fits file.
file_name : string
The file to write
Returns
-------
None
""" |
hdu = fits.PrimaryHDU(data)
hdu.header = header
hdulist = fits.HDUList([hdu])
hdulist.writeto(file_name, overwrite=True)
logging.info("Wrote {0}".format(file_name))
return |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.