Code
stringlengths 103
85.9k
| Summary
listlengths 0
94
|
|---|---|
Please provide a description of the function:def get_uncompleted_tasks(self):
all_tasks = self.get_tasks()
completed_tasks = self.get_completed_tasks()
return [t for t in all_tasks if t not in completed_tasks] | [
"Return a list of all uncompleted tasks in this project.\n\n .. warning:: Requires Todoist premium.\n\n :return: A list of all uncompleted tasks in this project.\n :rtype: list of :class:`pytodoist.todoist.Task`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.add_task('Install PyTodoist')\n >>> uncompleted_tasks = project.get_uncompleted_tasks()\n >>> for task in uncompleted_tasks:\n ... task.complete()\n "
] |
Please provide a description of the function:def get_completed_tasks(self):
self.owner.sync()
tasks = []
offset = 0
while True:
response = API.get_all_completed_tasks(self.owner.api_token,
limit=_PAGE_LIMIT,
offset=offset,
project_id=self.id)
_fail_if_contains_errors(response)
response_json = response.json()
tasks_json = response_json['items']
if len(tasks_json) == 0:
break # There are no more completed tasks to retreive.
for task_json in tasks_json:
project = self.owner.projects[task_json['project_id']]
tasks.append(Task(task_json, project))
offset += _PAGE_LIMIT
return tasks | [
"Return a list of all completed tasks in this project.\n\n :return: A list of all completed tasks in this project.\n :rtype: list of :class:`pytodoist.todoist.Task`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.complete()\n >>> completed_tasks = project.get_completed_tasks()\n >>> for task in completed_tasks:\n ... task.uncomplete()\n "
] |
Please provide a description of the function:def get_tasks(self):
self.owner.sync()
return [t for t in self.owner.tasks.values()
if t.project_id == self.id] | [
"Return all tasks in this project.\n\n :return: A list of all tasks in this project.class\n :rtype: list of :class:`pytodoist.todoist.Task`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.add_task('Install PyTodoist')\n >>> project.add_task('Have fun!')\n >>> tasks = project.get_tasks()\n >>> for task in tasks:\n ... print(task.content)\n Install PyTodoist\n Have fun!\n "
] |
Please provide a description of the function:def add_note(self, content):
args = {
'project_id': self.id,
'content': content
}
_perform_command(self.owner, 'note_add', args) | [
"Add a note to the project.\n\n .. warning:: Requires Todoist premium.\n\n :param content: The note content.\n :type content: str\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.add_note('Remember to update to the latest version.')\n "
] |
Please provide a description of the function:def get_notes(self):
self.owner.sync()
notes = self.owner.notes.values()
return [n for n in notes if n.project_id == self.id] | [
"Return a list of all of the project's notes.\n\n :return: A list of notes.\n :rtype: list of :class:`pytodoist.todoist.Note`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> notes = project.get_notes()\n "
] |
Please provide a description of the function:def share(self, email, message=None):
args = {
'project_id': self.id,
'email': email,
'message': message
}
_perform_command(self.owner, 'share_project', args) | [
"Share the project with another Todoist user.\n\n :param email: The other user's email address.\n :type email: str\n :param message: Optional message to send with the invitation.\n :type message: str\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.share('[email protected]')\n "
] |
Please provide a description of the function:def delete_collaborator(self, email):
args = {
'project_id': self.id,
'email': email,
}
_perform_command(self.owner, 'delete_collaborator', args) | [
"Remove a collaborating user from the shared project.\n\n :param email: The collaborator's email address.\n :type email: str\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.delete_collaborator('[email protected]')\n "
] |
Please provide a description of the function:def delete(self):
args = {'ids': [self.id]}
_perform_command(self.owner, 'project_delete', args)
del self.owner.projects[self.id] | [
"Delete the project.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> project.delete()\n "
] |
Please provide a description of the function:def complete(self):
args = {
'id': self.id
}
_perform_command(self.project.owner, 'item_close', args) | [
"Mark the task complete.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.complete()\n "
] |
Please provide a description of the function:def uncomplete(self):
args = {
'project_id': self.project.id,
'ids': [self.id]
}
owner = self.project.owner
_perform_command(owner, 'item_uncomplete', args) | [
"Mark the task uncomplete.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.uncomplete()\n "
] |
Please provide a description of the function:def get_notes(self):
owner = self.project.owner
owner.sync()
return [n for n in owner.notes.values() if n.item_id == self.id] | [
"Return all notes attached to this Task.\n\n :return: A list of all notes attached to this Task.\n :rtype: list of :class:`pytodoist.todoist.Note`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist.')\n >>> task.add_note('https://pypi.python.org/pypi')\n >>> notes = task.get_notes()\n >>> print(len(notes))\n 1\n "
] |
Please provide a description of the function:def move(self, project):
args = {
'project_items': {self.project.id: [self.id]},
'to_project': project.id
}
_perform_command(self.project.owner, 'item_move', args)
self.project = project | [
"Move this task to another project.\n\n :param project: The project to move the task to.\n :type project: :class:`pytodoist.todoist.Project`\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> print(task.project.name)\n PyTodoist\n >>> inbox = user.get_project('Inbox')\n >>> task.move(inbox)\n >>> print(task.project.name)\n Inbox\n "
] |
Please provide a description of the function:def add_date_reminder(self, service, due_date):
args = {
'item_id': self.id,
'service': service,
'type': 'absolute',
'due_date_utc': due_date
}
_perform_command(self.project.owner, 'reminder_add', args) | [
"Add a reminder to the task which activates on a given date.\n\n .. warning:: Requires Todoist premium.\n\n :param service: ```email```, ```sms``` or ```push``` for mobile.\n :type service: str\n :param due_date: The due date in UTC, formatted as\n ```YYYY-MM-DDTHH:MM```\n :type due_date: str\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.add_date_reminder('email', '2015-12-01T09:00')\n "
] |
Please provide a description of the function:def add_location_reminder(self, service, name, lat, long, trigger, radius):
args = {
'item_id': self.id,
'service': service,
'type': 'location',
'name': name,
'loc_lat': str(lat),
'loc_long': str(long),
'loc_trigger': trigger,
'radius': radius
}
_perform_command(self.project.owner, 'reminder_add', args) | [
"Add a reminder to the task which activates on at a given location.\n\n .. warning:: Requires Todoist premium.\n\n :param service: ```email```, ```sms``` or ```push``` for mobile.\n :type service: str\n :param name: An alias for the location.\n :type name: str\n :param lat: The location latitude.\n :type lat: float\n :param long: The location longitude.\n :type long: float\n :param trigger: ```on_enter``` or ```on_leave```.\n :type trigger: str\n :param radius: The radius around the location that is still considered\n the location.\n :type radius: float\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.add_location_reminder('email', 'Leave Glasgow',\n ... 55.8580, 4.2590, 'on_leave', 100)\n "
] |
Please provide a description of the function:def get_reminders(self):
owner = self.project.owner
return [r for r in owner.get_reminders() if r.task.id == self.id] | [
"Return a list of the task's reminders.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.add_date_reminder('email', '2015-12-01T09:00')\n >>> reminders = task.get_reminders()\n "
] |
Please provide a description of the function:def delete(self):
args = {'ids': [self.id]}
_perform_command(self.project.owner, 'item_delete', args)
del self.project.owner.tasks[self.id] | [
"Delete the task.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('Homework')\n >>> task = project.add_task('Read Chapter 4')\n >>> task.delete()\n "
] |
Please provide a description of the function:def delete(self):
args = {'id': self.id}
owner = self.task.project.owner
_perform_command(owner, 'note_delete', args) | [
"Delete the note, removing it from it's task.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist.')\n >>> note = task.add_note('https://pypi.python.org/pypi')\n >>> note.delete()\n >>> notes = task.get_notes()\n >>> print(len(notes))\n 0\n "
] |
Please provide a description of the function:def update(self):
args = {attr: getattr(self, attr) for attr in self.to_update}
args['id'] = self.id
_perform_command(self.owner, 'filter_update', args) | [
"Update the filter's details on Todoist.\n\n You must call this method to register any local attribute changes with\n Todoist.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('[email protected]', 'password')\n >>> overdue_filter = user.add_filter('Overdue', todoist.Query.OVERDUE)\n >>> overdue_filter.name = 'OVERDUE!'\n ... # At this point Todoist still thinks the name is 'Overdue'.\n >>> overdue_filter.update()\n ... # Now the name has been updated on Todoist.\n "
] |
Please provide a description of the function:def is_invalid_params_py2(func, *args, **kwargs):
funcargs, varargs, varkwargs, defaults = inspect.getargspec(func)
unexpected = set(kwargs.keys()) - set(funcargs)
if len(unexpected) > 0:
return True
params = [funcarg for funcarg in funcargs if funcarg not in kwargs]
funcargs_required = funcargs[:-len(defaults)] \
if defaults is not None \
else funcargs
params_required = [
funcarg for funcarg in funcargs_required
if funcarg not in kwargs
]
return not (len(params_required) <= len(args) <= len(params)) | [
" Check, whether function 'func' accepts parameters 'args', 'kwargs'.\n\n NOTE: Method is called after funct(*args, **kwargs) generated TypeError,\n it is aimed to destinguish TypeError because of invalid parameters from\n TypeError from inside the function.\n\n .. versionadded: 1.9.0\n\n "
] |
Please provide a description of the function:def is_invalid_params_py3(func, *args, **kwargs):
signature = inspect.signature(func)
parameters = signature.parameters
unexpected = set(kwargs.keys()) - set(parameters.keys())
if len(unexpected) > 0:
return True
params = [
parameter for name, parameter in parameters.items()
if name not in kwargs
]
params_required = [
param for param in params
if param.default is param.empty
]
return not (len(params_required) <= len(args) <= len(params)) | [
"\n Use inspect.signature instead of inspect.getargspec or\n inspect.getfullargspec (based on inspect.signature itself) as it provides\n more information about function parameters.\n\n .. versionadded: 1.11.2\n\n "
] |
Please provide a description of the function:def is_invalid_params(func, *args, **kwargs):
# For builtin functions inspect.getargspec(funct) return error. If builtin
# function generates TypeError, it is because of wrong parameters.
if not inspect.isfunction(func):
return True
if sys.version_info >= (3, 3):
return is_invalid_params_py3(func, *args, **kwargs)
else:
# NOTE: use Python2 method for Python 3.2 as well. Starting from Python
# 3.3 it is recommended to use inspect.signature instead.
# In Python 3.0 - 3.2 inspect.getfullargspec is preferred but these
# versions are almost not supported. Users should consider upgrading.
return is_invalid_params_py2(func, *args, **kwargs) | [
"\n Method:\n Validate pre-defined criteria, if any is True - function is invalid\n 0. func should be callable\n 1. kwargs should not have unexpected keywords\n 2. remove kwargs.keys from func.parameters\n 3. number of args should be <= remaining func.parameters\n 4. number of args should be >= remaining func.parameters less default\n "
] |
Please provide a description of the function:def add_method(self, f=None, name=None):
if name and not f:
return functools.partial(self.add_method, name=name)
self.method_map[name or f.__name__] = f
return f | [
" Add a method to the dispatcher.\n\n Parameters\n ----------\n f : callable\n Callable to be added.\n name : str, optional\n Name to register (the default is function **f** name)\n\n Notes\n -----\n When used as a decorator keeps callable object unmodified.\n\n Examples\n --------\n\n Use as method\n\n >>> d = Dispatcher()\n >>> d.add_method(lambda a, b: a + b, name=\"sum\")\n <function __main__.<lambda>>\n\n Or use as decorator\n\n >>> d = Dispatcher()\n >>> @d.add_method\n def mymethod(*args, **kwargs):\n print(args, kwargs)\n\n Or use as a decorator with a different function name\n >>> d = Dispatcher()\n >>> @d.add_method(name=\"my.method\")\n def mymethod(*args, **kwargs):\n print(args, kwargs)\n\n "
] |
Please provide a description of the function:def readme():
path = os.path.realpath(os.path.join(os.path.dirname(__file__), 'README.rst'))
handle = None
try:
handle = codecs.open(path, encoding='utf-8')
return handle.read(131072)
except IOError:
return ''
finally:
getattr(handle, 'close', lambda: None)() | [
"Try to read README.rst or return empty string if failed.\n\n :return: File contents.\n :rtype: str\n "
] |
Please provide a description of the function:def apply_text(incoming, func):
split = RE_SPLIT.split(incoming)
for i, item in enumerate(split):
if not item or RE_SPLIT.match(item):
continue
split[i] = func(item)
return incoming.__class__().join(split) | [
"Call `func` on text portions of incoming color string.\n\n :param iter incoming: Incoming string/ColorStr/string-like object to iterate.\n :param func: Function to call with string portion as first and only parameter.\n\n :return: Modified string, same class type as incoming string.\n "
] |
Please provide a description of the function:def decode(self, encoding='utf-8', errors='strict'):
original_class = getattr(self, 'original_class')
return original_class(super(ColorBytes, self).decode(encoding, errors)) | [
"Decode using the codec registered for encoding. Default encoding is 'utf-8'.\n\n errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors\n raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name\n registered with codecs.register_error that is able to handle UnicodeDecodeErrors.\n\n :param str encoding: Codec.\n :param str errors: Error handling scheme.\n "
] |
Please provide a description of the function:def center(self, width, fillchar=None):
if fillchar is not None:
result = self.value_no_colors.center(width, fillchar)
else:
result = self.value_no_colors.center(width)
return self.__class__(result.replace(self.value_no_colors, self.value_colors), keep_tags=True) | [
"Return centered in a string of length width. Padding is done using the specified fill character or space.\n\n :param int width: Length of output string.\n :param str fillchar: Use this character instead of spaces.\n "
] |
Please provide a description of the function:def count(self, sub, start=0, end=-1):
return self.value_no_colors.count(sub, start, end) | [
"Return the number of non-overlapping occurrences of substring sub in string[start:end].\n\n Optional arguments start and end are interpreted as in slice notation.\n\n :param str sub: Substring to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def endswith(self, suffix, start=0, end=None):
args = [suffix, start] + ([] if end is None else [end])
return self.value_no_colors.endswith(*args) | [
"Return True if ends with the specified suffix, False otherwise.\n\n With optional start, test beginning at that position. With optional end, stop comparing at that position.\n suffix can also be a tuple of strings to try.\n\n :param str suffix: Suffix to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def encode(self, encoding=None, errors='strict'):
return ColorBytes(super(ColorStr, self).encode(encoding, errors), original_class=self.__class__) | [
"Encode using the codec registered for encoding. encoding defaults to the default encoding.\n\n errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors\n raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any\n other name registered with codecs.register_error that is able to handle UnicodeEncodeErrors.\n\n :param str encoding: Codec.\n :param str errors: Error handling scheme.\n "
] |
Please provide a description of the function:def decode(self, encoding=None, errors='strict'):
return self.__class__(super(ColorStr, self).decode(encoding, errors), keep_tags=True) | [
"Decode using the codec registered for encoding. encoding defaults to the default encoding.\n\n errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors\n raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name\n registered with codecs.register_error that is able to handle UnicodeDecodeErrors.\n\n :param str encoding: Codec.\n :param str errors: Error handling scheme.\n "
] |
Please provide a description of the function:def find(self, sub, start=None, end=None):
return self.value_no_colors.find(sub, start, end) | [
"Return the lowest index where substring sub is found, such that sub is contained within string[start:end].\n\n Optional arguments start and end are interpreted as in slice notation.\n\n :param str sub: Substring to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def format(self, *args, **kwargs):
return self.__class__(super(ColorStr, self).format(*args, **kwargs), keep_tags=True) | [
"Return a formatted version, using substitutions from args and kwargs.\n\n The substitutions are identified by braces ('{' and '}').\n "
] |
Please provide a description of the function:def index(self, sub, start=None, end=None):
return self.value_no_colors.index(sub, start, end) | [
"Like S.find() but raise ValueError when the substring is not found.\n\n :param str sub: Substring to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def join(self, iterable):
return self.__class__(super(ColorStr, self).join(iterable), keep_tags=True) | [
"Return a string which is the concatenation of the strings in the iterable.\n\n :param iterable: Join items in this iterable.\n "
] |
Please provide a description of the function:def rfind(self, sub, start=None, end=None):
return self.value_no_colors.rfind(sub, start, end) | [
"Return the highest index where substring sub is found, such that sub is contained within string[start:end].\n\n Optional arguments start and end are interpreted as in slice notation.\n\n :param str sub: Substring to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def rindex(self, sub, start=None, end=None):
return self.value_no_colors.rindex(sub, start, end) | [
"Like .rfind() but raise ValueError when the substring is not found.\n\n :param str sub: Substring to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def splitlines(self, keepends=False):
return [self.__class__(l) for l in self.value_colors.splitlines(keepends)] | [
"Return a list of the lines in the string, breaking at line boundaries.\n\n Line breaks are not included in the resulting list unless keepends is given and True.\n\n :param bool keepends: Include linebreaks.\n "
] |
Please provide a description of the function:def startswith(self, prefix, start=0, end=-1):
return self.value_no_colors.startswith(prefix, start, end) | [
"Return True if string starts with the specified prefix, False otherwise.\n\n With optional start, test beginning at that position. With optional end, stop comparing at that position. prefix\n can also be a tuple of strings to try.\n\n :param str prefix: Prefix to search.\n :param int start: Beginning position.\n :param int end: Stop comparison at this position.\n "
] |
Please provide a description of the function:def zfill(self, width):
if not self.value_no_colors:
result = self.value_no_colors.zfill(width)
else:
result = self.value_colors.replace(self.value_no_colors, self.value_no_colors.zfill(width))
return self.__class__(result, keep_tags=True) | [
"Pad a numeric string with zeros on the left, to fill a field of the specified width.\n\n The string is never truncated.\n\n :param int width: Length of output string.\n "
] |
Please provide a description of the function:def colorize(cls, color, string, auto=False):
tag = '{0}{1}'.format('auto' if auto else '', color)
return cls('{%s}%s{/%s}' % (tag, string, tag)) | [
"Color-code entire string using specified color.\n\n :param str color: Color of string.\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def black(cls, string, auto=False):
return cls.colorize('black', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgblack(cls, string, auto=False):
return cls.colorize('bgblack', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def red(cls, string, auto=False):
return cls.colorize('red', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgred(cls, string, auto=False):
return cls.colorize('bgred', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def green(cls, string, auto=False):
return cls.colorize('green', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bggreen(cls, string, auto=False):
return cls.colorize('bggreen', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def yellow(cls, string, auto=False):
return cls.colorize('yellow', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgyellow(cls, string, auto=False):
return cls.colorize('bgyellow', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def blue(cls, string, auto=False):
return cls.colorize('blue', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgblue(cls, string, auto=False):
return cls.colorize('bgblue', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def magenta(cls, string, auto=False):
return cls.colorize('magenta', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgmagenta(cls, string, auto=False):
return cls.colorize('bgmagenta', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def cyan(cls, string, auto=False):
return cls.colorize('cyan', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgcyan(cls, string, auto=False):
return cls.colorize('bgcyan', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def white(cls, string, auto=False):
return cls.colorize('white', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def bgwhite(cls, string, auto=False):
return cls.colorize('bgwhite', string, auto=auto) | [
"Color-code entire string.\n\n :param str string: String to colorize.\n :param bool auto: Enable auto-color (dark/light terminal).\n\n :return: Class instance for colorized string.\n :rtype: Color\n "
] |
Please provide a description of the function:def list_tags():
# Build reverse dictionary. Keys are closing tags, values are [closing ansi, opening tag, opening ansi].
reverse_dict = dict()
for tag, ansi in sorted(BASE_CODES.items()):
if tag.startswith('/'):
reverse_dict[tag] = [ansi, None, None]
else:
reverse_dict['/' + tag][1:] = [tag, ansi]
# Collapse
four_item_tuples = [(v[1], k, v[2], v[0]) for k, v in reverse_dict.items()]
# Sort.
def sorter(four_item):
if not four_item[2]: # /all /fg /bg
return four_item[3] - 200
if four_item[2] < 10 or four_item[0].startswith('auto'): # b f i u or auto colors
return four_item[2] - 100
return four_item[2]
four_item_tuples.sort(key=sorter)
return four_item_tuples | [
"List the available tags.\n\n :return: List of 4-item tuples: opening tag, closing tag, main ansi value, closing ansi value.\n :rtype: list\n ",
"Sort /all /fg /bg first, then b i u flash, then auto colors, then dark colors, finally light colors.\n\n :param iter four_item: [opening tag, closing tag, main ansi value, closing ansi value]\n\n :return Sorting weight.\n :rtype: int\n "
] |
Please provide a description of the function:def disable_if_no_tty(cls):
if sys.stdout.isatty() or sys.stderr.isatty():
return False
cls.disable_all_colors()
return True | [
"Disable all colors only if there is no TTY available.\n\n :return: True if colors are disabled, False if stderr or stdout is a TTY.\n :rtype: bool\n "
] |
Please provide a description of the function:def init_kernel32(kernel32=None):
if not kernel32:
kernel32 = ctypes.LibraryLoader(ctypes.WinDLL).kernel32 # Load our own instance. Unique memory address.
kernel32.GetStdHandle.argtypes = [ctypes.c_ulong]
kernel32.GetStdHandle.restype = ctypes.c_void_p
kernel32.GetConsoleScreenBufferInfo.argtypes = [
ctypes.c_void_p,
ctypes.POINTER(ConsoleScreenBufferInfo),
]
kernel32.GetConsoleScreenBufferInfo.restype = ctypes.c_long
# Get handles.
if hasattr(sys.stderr, '_original_stream'):
stderr = INVALID_HANDLE_VALUE
else:
stderr = kernel32.GetStdHandle(STD_ERROR_HANDLE)
if hasattr(sys.stdout, '_original_stream'):
stdout = INVALID_HANDLE_VALUE
else:
stdout = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
return kernel32, stderr, stdout | [
"Load a unique instance of WinDLL into memory, set arg/return types, and get stdout/err handles.\n\n 1. Since we are setting DLL function argument types and return types, we need to maintain our own instance of\n kernel32 to prevent overriding (or being overwritten by) user's own changes to ctypes.windll.kernel32.\n 2. While we're doing all this we might as well get the handles to STDOUT and STDERR streams.\n 3. If either stream has already been replaced set return value to INVALID_HANDLE_VALUE to indicate it shouldn't be\n replaced.\n\n :raise AttributeError: When called on a non-Windows platform.\n\n :param kernel32: Optional mock kernel32 object. For testing.\n\n :return: Loaded kernel32 instance, stderr handle (int), stdout handle (int).\n :rtype: tuple\n "
] |
Please provide a description of the function:def get_console_info(kernel32, handle):
# Query Win32 API.
csbi = ConsoleScreenBufferInfo() # Populated by GetConsoleScreenBufferInfo.
lpcsbi = ctypes.byref(csbi)
dword = ctypes.c_ulong() # Populated by GetConsoleMode.
lpdword = ctypes.byref(dword)
if not kernel32.GetConsoleScreenBufferInfo(handle, lpcsbi) or not kernel32.GetConsoleMode(handle, lpdword):
raise ctypes.WinError()
# Parse data.
# buffer_width = int(csbi.dwSize.X - 1)
# buffer_height = int(csbi.dwSize.Y)
# terminal_width = int(csbi.srWindow.Right - csbi.srWindow.Left)
# terminal_height = int(csbi.srWindow.Bottom - csbi.srWindow.Top)
fg_color = csbi.wAttributes % 16
bg_color = csbi.wAttributes & 240
native_ansi = bool(dword.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
return fg_color, bg_color, native_ansi | [
"Get information about this current console window.\n\n http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231\n https://code.google.com/p/colorama/issues/detail?id=47\n https://bitbucket.org/pytest-dev/py/src/4617fe46/py/_io/terminalwriter.py\n\n Windows 10 Insider since around February 2016 finally introduced support for ANSI colors. No need to replace stdout\n and stderr streams to intercept colors and issue multiple SetConsoleTextAttribute() calls for these consoles.\n\n :raise OSError: When GetConsoleScreenBufferInfo or GetConsoleMode API calls fail.\n\n :param ctypes.windll.kernel32 kernel32: Loaded kernel32 instance.\n :param int handle: stderr or stdout handle.\n\n :return: Foreground and background colors (integers) as well as native ANSI support (bool).\n :rtype: tuple\n "
] |
Please provide a description of the function:def bg_color_native_ansi(kernel32, stderr, stdout):
try:
if stderr == INVALID_HANDLE_VALUE:
raise OSError
bg_color, native_ansi = get_console_info(kernel32, stderr)[1:]
except OSError:
try:
if stdout == INVALID_HANDLE_VALUE:
raise OSError
bg_color, native_ansi = get_console_info(kernel32, stdout)[1:]
except OSError:
bg_color, native_ansi = WINDOWS_CODES['black'], False
return bg_color, native_ansi | [
"Get background color and if console supports ANSI colors natively for both streams.\n\n :param ctypes.windll.kernel32 kernel32: Loaded kernel32 instance.\n :param int stderr: stderr handle.\n :param int stdout: stdout handle.\n\n :return: Background color (int) and native ANSI support (bool).\n :rtype: tuple\n "
] |
Please provide a description of the function:def colors(self):
try:
return get_console_info(self._kernel32, self._stream_handle)[:2]
except OSError:
return WINDOWS_CODES['white'], WINDOWS_CODES['black'] | [
"Return the current foreground and background colors."
] |
Please provide a description of the function:def colors(self, color_code):
if color_code is None:
color_code = WINDOWS_CODES['/all']
# Get current color code.
current_fg, current_bg = self.colors
# Handle special negative codes. Also determine the final color code.
if color_code == WINDOWS_CODES['/fg']:
final_color_code = self.default_fg | current_bg # Reset the foreground only.
elif color_code == WINDOWS_CODES['/bg']:
final_color_code = current_fg | self.default_bg # Reset the background only.
elif color_code == WINDOWS_CODES['/all']:
final_color_code = self.default_fg | self.default_bg # Reset both.
elif color_code == WINDOWS_CODES['bgblack']:
final_color_code = current_fg # Black background.
else:
new_is_bg = color_code in self.ALL_BG_CODES
final_color_code = color_code | (current_fg if new_is_bg else current_bg)
# Set new code.
self._kernel32.SetConsoleTextAttribute(self._stream_handle, final_color_code) | [
"Change the foreground and background colors for subsequently printed characters.\n\n None resets colors to their original values (when class was instantiated).\n\n Since setting a color requires including both foreground and background codes (merged), setting just the\n foreground color resets the background color to black, and vice versa.\n\n This function first gets the current background and foreground colors, merges in the requested color code, and\n sets the result.\n\n However if we need to remove just the foreground color but leave the background color the same (or vice versa)\n such as when {/red} is used, we must merge the default foreground color with the current background color. This\n is the reason for those negative values.\n\n :param int color_code: Color code from WINDOWS_CODES.\n "
] |
Please provide a description of the function:def write(self, p_str):
for segment in RE_SPLIT.split(p_str):
if not segment:
# Empty string. p_str probably starts with colors so the first item is always ''.
continue
if not RE_SPLIT.match(segment):
# No color codes, print regular text.
print(segment, file=self._original_stream, end='')
self._original_stream.flush()
continue
for color_code in (int(c) for c in RE_NUMBER_SEARCH.findall(segment)[0].split(';')):
if color_code in self.COMPILED_CODES:
self.colors = self.COMPILED_CODES[color_code] | [
"Write to stream.\n\n :param str p_str: string to print.\n "
] |
Please provide a description of the function:def disable(cls):
# Skip if not on Windows.
if not IS_WINDOWS:
return False
# Restore default colors.
if hasattr(sys.stderr, '_original_stream'):
getattr(sys, 'stderr').color = None
if hasattr(sys.stdout, '_original_stream'):
getattr(sys, 'stdout').color = None
# Restore original streams.
changed = False
if hasattr(sys.stderr, '_original_stream'):
changed = True
sys.stderr = getattr(sys.stderr, '_original_stream')
if hasattr(sys.stdout, '_original_stream'):
changed = True
sys.stdout = getattr(sys.stdout, '_original_stream')
return changed | [
"Restore sys.stderr and sys.stdout to their original objects. Resets colors to their original values.\n\n :return: If streams restored successfully.\n :rtype: bool\n "
] |
Please provide a description of the function:def enable(cls, auto_colors=False, reset_atexit=False):
if not IS_WINDOWS:
return False # Windows only.
# Get values from init_kernel32().
kernel32, stderr, stdout = init_kernel32()
if stderr == INVALID_HANDLE_VALUE and stdout == INVALID_HANDLE_VALUE:
return False # No valid handles, nothing to do.
# Get console info.
bg_color, native_ansi = bg_color_native_ansi(kernel32, stderr, stdout)
# Set auto colors:
if auto_colors:
if bg_color in (112, 96, 240, 176, 224, 208, 160):
ANSICodeMapping.set_light_background()
else:
ANSICodeMapping.set_dark_background()
# Don't replace streams if ANSI codes are natively supported.
if native_ansi:
return False
# Reset on exit if requested.
if reset_atexit:
atexit.register(cls.disable)
# Overwrite stream references.
if stderr != INVALID_HANDLE_VALUE:
sys.stderr.flush()
sys.stderr = WindowsStream(kernel32, stderr, sys.stderr)
if stdout != INVALID_HANDLE_VALUE:
sys.stdout.flush()
sys.stdout = WindowsStream(kernel32, stdout, sys.stdout)
return True | [
"Enable color text with print() or sys.stdout.write() (stderr too).\n\n :param bool auto_colors: Automatically selects dark or light colors based on current terminal's background\n color. Only works with {autored} and related tags.\n :param bool reset_atexit: Resets original colors upon Python exit (in case you forget to reset it yourself with\n a closing tag). Does nothing on native ANSI consoles.\n\n :return: If streams replaced successfully.\n :rtype: bool\n "
] |
Please provide a description of the function:def prune_overridden(ansi_string):
multi_seqs = set(p for p in RE_ANSI.findall(ansi_string) if ';' in p[1]) # Sequences with multiple color codes.
for escape, codes in multi_seqs:
r_codes = list(reversed(codes.split(';')))
# Nuke everything before {/all}.
try:
r_codes = r_codes[:r_codes.index('0') + 1]
except ValueError:
pass
# Thin out groups.
for group in CODE_GROUPS:
for pos in reversed([i for i, n in enumerate(r_codes) if n in group][1:]):
r_codes.pop(pos)
# Done.
reduced_codes = ';'.join(sorted(r_codes, key=int))
if codes != reduced_codes:
ansi_string = ansi_string.replace(escape, '\033[' + reduced_codes + 'm')
return ansi_string | [
"Remove color codes that are rendered ineffective by subsequent codes in one escape sequence then sort codes.\n\n :param str ansi_string: Incoming ansi_string with ANSI color codes.\n\n :return: Color string with pruned color sequences.\n :rtype: str\n "
] |
Please provide a description of the function:def parse_input(tagged_string, disable_colors, keep_tags):
codes = ANSICodeMapping(tagged_string)
output_colors = getattr(tagged_string, 'value_colors', tagged_string)
# Convert: '{b}{red}' -> '\033[1m\033[31m'
if not keep_tags:
for tag, replacement in (('{' + k + '}', '' if v is None else '\033[%dm' % v) for k, v in codes.items()):
output_colors = output_colors.replace(tag, replacement)
# Strip colors.
output_no_colors = RE_ANSI.sub('', output_colors)
if disable_colors:
return output_no_colors, output_no_colors
# Combine: '\033[1m\033[31m' -> '\033[1;31m'
while True:
simplified = RE_COMBINE.sub(r'\033[\1;\2m', output_colors)
if simplified == output_colors:
break
output_colors = simplified
# Prune: '\033[31;32;33;34;35m' -> '\033[35m'
output_colors = prune_overridden(output_colors)
# Deduplicate: '\033[1;mT\033[1;mE\033[1;mS\033[1;mT' -> '\033[1;mTEST'
previous_escape = None
segments = list()
for item in (i for i in RE_SPLIT.split(output_colors) if i):
if RE_SPLIT.match(item):
if item != previous_escape:
segments.append(item)
previous_escape = item
else:
segments.append(item)
output_colors = ''.join(segments)
return output_colors, output_no_colors | [
"Perform the actual conversion of tags to ANSI escaped codes.\n\n Provides a version of the input without any colors for len() and other methods.\n\n :param str tagged_string: The input unicode value.\n :param bool disable_colors: Strip all colors in both outputs.\n :param bool keep_tags: Skip parsing curly bracket tags into ANSI escape sequences.\n\n :return: 2-item tuple. First item is the parsed output. Second item is a version of the input without any colors.\n :rtype: tuple\n "
] |
Please provide a description of the function:def build_color_index(ansi_string):
mapping = list()
color_offset = 0
for item in (i for i in RE_SPLIT.split(ansi_string) if i):
if RE_SPLIT.match(item):
color_offset += len(item)
else:
for _ in range(len(item)):
mapping.append(color_offset)
color_offset += 1
return tuple(mapping) | [
"Build an index between visible characters and a string with invisible color codes.\n\n :param str ansi_string: String with color codes (ANSI escape sequences).\n\n :return: Position of visible characters in color string (indexes match non-color string).\n :rtype: tuple\n "
] |
Please provide a description of the function:def find_char_color(ansi_string, pos):
result = list()
position = 0 # Set to None when character is found.
for item in (i for i in RE_SPLIT.split(ansi_string) if i):
if RE_SPLIT.match(item):
result.append(item)
if position is not None:
position += len(item)
elif position is not None:
for char in item:
if position == pos:
result.append(char)
position = None
break
position += 1
return ''.join(result) | [
"Determine what color a character is in the string.\n\n :param str ansi_string: String with color codes (ANSI escape sequences).\n :param int pos: Position of the character in the ansi_string.\n\n :return: Character along with all surrounding color codes.\n :rtype: str\n "
] |
Please provide a description of the function:def main():
if OPTIONS.get('--no-colors'):
disable_all_colors()
elif OPTIONS.get('--colors'):
enable_all_colors()
if is_enabled() and os.name == 'nt':
Windows.enable(auto_colors=True, reset_atexit=True)
elif OPTIONS.get('--light-bg'):
set_light_background()
elif OPTIONS.get('--dark-bg'):
set_dark_background()
# Light or dark colors.
print('Autocolors for all backgrounds:')
print(Color(' {autoblack}Black{/black} {autored}Red{/red} {autogreen}Green{/green} '), end='')
print(Color('{autoyellow}Yellow{/yellow} {autoblue}Blue{/blue} {automagenta}Magenta{/magenta} '), end='')
print(Color('{autocyan}Cyan{/cyan} {autowhite}White{/white}'))
print(Color(' {autobgblack}{autoblack}Black{/black}{/bgblack} '), end='')
print(Color('{autobgblack}{autored}Red{/red}{/bgblack} {autobgblack}{autogreen}Green{/green}{/bgblack} '), end='')
print(Color('{autobgblack}{autoyellow}Yellow{/yellow}{/bgblack} '), end='')
print(Color('{autobgblack}{autoblue}Blue{/blue}{/bgblack} '), end='')
print(Color('{autobgblack}{automagenta}Magenta{/magenta}{/bgblack} '), end='')
print(Color('{autobgblack}{autocyan}Cyan{/cyan}{/bgblack} {autobgblack}{autowhite}White{/white}{/bgblack}'))
print(Color(' {autobgred}{autoblack}Black{/black}{/bgred} {autobgred}{autored}Red{/red}{/bgred} '), end='')
print(Color('{autobgred}{autogreen}Green{/green}{/bgred} {autobgred}{autoyellow}Yellow{/yellow}{/bgred} '), end='')
print(Color('{autobgred}{autoblue}Blue{/blue}{/bgred} {autobgred}{automagenta}Magenta{/magenta}{/bgred} '), end='')
print(Color('{autobgred}{autocyan}Cyan{/cyan}{/bgred} {autobgred}{autowhite}White{/white}{/bgred}'))
print(Color(' {autobggreen}{autoblack}Black{/black}{/bggreen} '), end='')
print(Color('{autobggreen}{autored}Red{/red}{/bggreen} {autobggreen}{autogreen}Green{/green}{/bggreen} '), end='')
print(Color('{autobggreen}{autoyellow}Yellow{/yellow}{/bggreen} '), end='')
print(Color('{autobggreen}{autoblue}Blue{/blue}{/bggreen} '), end='')
print(Color('{autobggreen}{automagenta}Magenta{/magenta}{/bggreen} '), end='')
print(Color('{autobggreen}{autocyan}Cyan{/cyan}{/bggreen} {autobggreen}{autowhite}White{/white}{/bggreen}'))
print(Color(' {autobgyellow}{autoblack}Black{/black}{/bgyellow} '), end='')
print(Color('{autobgyellow}{autored}Red{/red}{/bgyellow} '), end='')
print(Color('{autobgyellow}{autogreen}Green{/green}{/bgyellow} '), end='')
print(Color('{autobgyellow}{autoyellow}Yellow{/yellow}{/bgyellow} '), end='')
print(Color('{autobgyellow}{autoblue}Blue{/blue}{/bgyellow} '), end='')
print(Color('{autobgyellow}{automagenta}Magenta{/magenta}{/bgyellow} '), end='')
print(Color('{autobgyellow}{autocyan}Cyan{/cyan}{/bgyellow} {autobgyellow}{autowhite}White{/white}{/bgyellow}'))
print(Color(' {autobgblue}{autoblack}Black{/black}{/bgblue} {autobgblue}{autored}Red{/red}{/bgblue} '), end='')
print(Color('{autobgblue}{autogreen}Green{/green}{/bgblue} '), end='')
print(Color('{autobgblue}{autoyellow}Yellow{/yellow}{/bgblue} {autobgblue}{autoblue}Blue{/blue}{/bgblue} '), end='')
print(Color('{autobgblue}{automagenta}Magenta{/magenta}{/bgblue} '), end='')
print(Color('{autobgblue}{autocyan}Cyan{/cyan}{/bgblue} {autobgblue}{autowhite}White{/white}{/bgblue}'))
print(Color(' {autobgmagenta}{autoblack}Black{/black}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autored}Red{/red}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autogreen}Green{/green}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autoyellow}Yellow{/yellow}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autoblue}Blue{/blue}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{automagenta}Magenta{/magenta}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autocyan}Cyan{/cyan}{/bgmagenta} '), end='')
print(Color('{autobgmagenta}{autowhite}White{/white}{/bgmagenta}'))
print(Color(' {autobgcyan}{autoblack}Black{/black}{/bgcyan} {autobgcyan}{autored}Red{/red}{/bgcyan} '), end='')
print(Color('{autobgcyan}{autogreen}Green{/green}{/bgcyan} '), end='')
print(Color('{autobgcyan}{autoyellow}Yellow{/yellow}{/bgcyan} {autobgcyan}{autoblue}Blue{/blue}{/bgcyan} '), end='')
print(Color('{autobgcyan}{automagenta}Magenta{/magenta}{/bgcyan} '), end='')
print(Color('{autobgcyan}{autocyan}Cyan{/cyan}{/bgcyan} {autobgcyan}{autowhite}White{/white}{/bgcyan}'))
print(Color(' {autobgwhite}{autoblack}Black{/black}{/bgwhite} '), end='')
print(Color('{autobgwhite}{autored}Red{/red}{/bgwhite} {autobgwhite}{autogreen}Green{/green}{/bgwhite} '), end='')
print(Color('{autobgwhite}{autoyellow}Yellow{/yellow}{/bgwhite} '), end='')
print(Color('{autobgwhite}{autoblue}Blue{/blue}{/bgwhite} '), end='')
print(Color('{autobgwhite}{automagenta}Magenta{/magenta}{/bgwhite} '), end='')
print(Color('{autobgwhite}{autocyan}Cyan{/cyan}{/bgwhite} {autobgwhite}{autowhite}White{/white}{/bgwhite}'))
print()
# Light colors.
print('Light colors for dark backgrounds:')
print(Color(' {hiblack}Black{/black} {hired}Red{/red} {higreen}Green{/green} '), end='')
print(Color('{hiyellow}Yellow{/yellow} {hiblue}Blue{/blue} {himagenta}Magenta{/magenta} '), end='')
print(Color('{hicyan}Cyan{/cyan} {hiwhite}White{/white}'))
print(Color(' {hibgblack}{hiblack}Black{/black}{/bgblack} '), end='')
print(Color('{hibgblack}{hired}Red{/red}{/bgblack} {hibgblack}{higreen}Green{/green}{/bgblack} '), end='')
print(Color('{hibgblack}{hiyellow}Yellow{/yellow}{/bgblack} '), end='')
print(Color('{hibgblack}{hiblue}Blue{/blue}{/bgblack} '), end='')
print(Color('{hibgblack}{himagenta}Magenta{/magenta}{/bgblack} '), end='')
print(Color('{hibgblack}{hicyan}Cyan{/cyan}{/bgblack} {hibgblack}{hiwhite}White{/white}{/bgblack}'))
print(Color(' {hibgred}{hiblack}Black{/black}{/bgred} {hibgred}{hired}Red{/red}{/bgred} '), end='')
print(Color('{hibgred}{higreen}Green{/green}{/bgred} {hibgred}{hiyellow}Yellow{/yellow}{/bgred} '), end='')
print(Color('{hibgred}{hiblue}Blue{/blue}{/bgred} {hibgred}{himagenta}Magenta{/magenta}{/bgred} '), end='')
print(Color('{hibgred}{hicyan}Cyan{/cyan}{/bgred} {hibgred}{hiwhite}White{/white}{/bgred}'))
print(Color(' {hibggreen}{hiblack}Black{/black}{/bggreen} '), end='')
print(Color('{hibggreen}{hired}Red{/red}{/bggreen} {hibggreen}{higreen}Green{/green}{/bggreen} '), end='')
print(Color('{hibggreen}{hiyellow}Yellow{/yellow}{/bggreen} '), end='')
print(Color('{hibggreen}{hiblue}Blue{/blue}{/bggreen} '), end='')
print(Color('{hibggreen}{himagenta}Magenta{/magenta}{/bggreen} '), end='')
print(Color('{hibggreen}{hicyan}Cyan{/cyan}{/bggreen} {hibggreen}{hiwhite}White{/white}{/bggreen}'))
print(Color(' {hibgyellow}{hiblack}Black{/black}{/bgyellow} '), end='')
print(Color('{hibgyellow}{hired}Red{/red}{/bgyellow} '), end='')
print(Color('{hibgyellow}{higreen}Green{/green}{/bgyellow} '), end='')
print(Color('{hibgyellow}{hiyellow}Yellow{/yellow}{/bgyellow} '), end='')
print(Color('{hibgyellow}{hiblue}Blue{/blue}{/bgyellow} '), end='')
print(Color('{hibgyellow}{himagenta}Magenta{/magenta}{/bgyellow} '), end='')
print(Color('{hibgyellow}{hicyan}Cyan{/cyan}{/bgyellow} {hibgyellow}{hiwhite}White{/white}{/bgyellow}'))
print(Color(' {hibgblue}{hiblack}Black{/black}{/bgblue} {hibgblue}{hired}Red{/red}{/bgblue} '), end='')
print(Color('{hibgblue}{higreen}Green{/green}{/bgblue} '), end='')
print(Color('{hibgblue}{hiyellow}Yellow{/yellow}{/bgblue} {hibgblue}{hiblue}Blue{/blue}{/bgblue} '), end='')
print(Color('{hibgblue}{himagenta}Magenta{/magenta}{/bgblue} '), end='')
print(Color('{hibgblue}{hicyan}Cyan{/cyan}{/bgblue} {hibgblue}{hiwhite}White{/white}{/bgblue}'))
print(Color(' {hibgmagenta}{hiblack}Black{/black}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{hired}Red{/red}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{higreen}Green{/green}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{hiyellow}Yellow{/yellow}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{hiblue}Blue{/blue}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{himagenta}Magenta{/magenta}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{hicyan}Cyan{/cyan}{/bgmagenta} '), end='')
print(Color('{hibgmagenta}{hiwhite}White{/white}{/bgmagenta}'))
print(Color(' {hibgcyan}{hiblack}Black{/black}{/bgcyan} {hibgcyan}{hired}Red{/red}{/bgcyan} '), end='')
print(Color('{hibgcyan}{higreen}Green{/green}{/bgcyan} '), end='')
print(Color('{hibgcyan}{hiyellow}Yellow{/yellow}{/bgcyan} {hibgcyan}{hiblue}Blue{/blue}{/bgcyan} '), end='')
print(Color('{hibgcyan}{himagenta}Magenta{/magenta}{/bgcyan} '), end='')
print(Color('{hibgcyan}{hicyan}Cyan{/cyan}{/bgcyan} {hibgcyan}{hiwhite}White{/white}{/bgcyan}'))
print(Color(' {hibgwhite}{hiblack}Black{/black}{/bgwhite} '), end='')
print(Color('{hibgwhite}{hired}Red{/red}{/bgwhite} {hibgwhite}{higreen}Green{/green}{/bgwhite} '), end='')
print(Color('{hibgwhite}{hiyellow}Yellow{/yellow}{/bgwhite} '), end='')
print(Color('{hibgwhite}{hiblue}Blue{/blue}{/bgwhite} '), end='')
print(Color('{hibgwhite}{himagenta}Magenta{/magenta}{/bgwhite} '), end='')
print(Color('{hibgwhite}{hicyan}Cyan{/cyan}{/bgwhite} {hibgwhite}{hiwhite}White{/white}{/bgwhite}'))
print()
# Dark colors.
print('Dark colors for light backgrounds:')
print(Color(' {black}Black{/black} {red}Red{/red} {green}Green{/green} {yellow}Yellow{/yellow} '), end='')
print(Color('{blue}Blue{/blue} {magenta}Magenta{/magenta} {cyan}Cyan{/cyan} {white}White{/white}'))
print(Color(' {bgblack}{black}Black{/black}{/bgblack} {bgblack}{red}Red{/red}{/bgblack} '), end='')
print(Color('{bgblack}{green}Green{/green}{/bgblack} {bgblack}{yellow}Yellow{/yellow}{/bgblack} '), end='')
print(Color('{bgblack}{blue}Blue{/blue}{/bgblack} {bgblack}{magenta}Magenta{/magenta}{/bgblack} '), end='')
print(Color('{bgblack}{cyan}Cyan{/cyan}{/bgblack} {bgblack}{white}White{/white}{/bgblack}'))
print(Color(' {bgred}{black}Black{/black}{/bgred} {bgred}{red}Red{/red}{/bgred} '), end='')
print(Color('{bgred}{green}Green{/green}{/bgred} {bgred}{yellow}Yellow{/yellow}{/bgred} '), end='')
print(Color('{bgred}{blue}Blue{/blue}{/bgred} {bgred}{magenta}Magenta{/magenta}{/bgred} '), end='')
print(Color('{bgred}{cyan}Cyan{/cyan}{/bgred} {bgred}{white}White{/white}{/bgred}'))
print(Color(' {bggreen}{black}Black{/black}{/bggreen} {bggreen}{red}Red{/red}{/bggreen} '), end='')
print(Color('{bggreen}{green}Green{/green}{/bggreen} {bggreen}{yellow}Yellow{/yellow}{/bggreen} '), end='')
print(Color('{bggreen}{blue}Blue{/blue}{/bggreen} {bggreen}{magenta}Magenta{/magenta}{/bggreen} '), end='')
print(Color('{bggreen}{cyan}Cyan{/cyan}{/bggreen} {bggreen}{white}White{/white}{/bggreen}'))
print(Color(' {bgyellow}{black}Black{/black}{/bgyellow} {bgyellow}{red}Red{/red}{/bgyellow} '), end='')
print(Color('{bgyellow}{green}Green{/green}{/bgyellow} {bgyellow}{yellow}Yellow{/yellow}{/bgyellow} '), end='')
print(Color('{bgyellow}{blue}Blue{/blue}{/bgyellow} {bgyellow}{magenta}Magenta{/magenta}{/bgyellow} '), end='')
print(Color('{bgyellow}{cyan}Cyan{/cyan}{/bgyellow} {bgyellow}{white}White{/white}{/bgyellow}'))
print(Color(' {bgblue}{black}Black{/black}{/bgblue} {bgblue}{red}Red{/red}{/bgblue} '), end='')
print(Color('{bgblue}{green}Green{/green}{/bgblue} {bgblue}{yellow}Yellow{/yellow}{/bgblue} '), end='')
print(Color('{bgblue}{blue}Blue{/blue}{/bgblue} {bgblue}{magenta}Magenta{/magenta}{/bgblue} '), end='')
print(Color('{bgblue}{cyan}Cyan{/cyan}{/bgblue} {bgblue}{white}White{/white}{/bgblue}'))
print(Color(' {bgmagenta}{black}Black{/black}{/bgmagenta} {bgmagenta}{red}Red{/red}{/bgmagenta} '), end='')
print(Color('{bgmagenta}{green}Green{/green}{/bgmagenta} {bgmagenta}{yellow}Yellow{/yellow}{/bgmagenta} '), end='')
print(Color('{bgmagenta}{blue}Blue{/blue}{/bgmagenta} {bgmagenta}{magenta}Magenta{/magenta}{/bgmagenta} '), end='')
print(Color('{bgmagenta}{cyan}Cyan{/cyan}{/bgmagenta} {bgmagenta}{white}White{/white}{/bgmagenta}'))
print(Color(' {bgcyan}{black}Black{/black}{/bgcyan} {bgcyan}{red}Red{/red}{/bgcyan} '), end='')
print(Color('{bgcyan}{green}Green{/green}{/bgcyan} {bgcyan}{yellow}Yellow{/yellow}{/bgcyan} '), end='')
print(Color('{bgcyan}{blue}Blue{/blue}{/bgcyan} {bgcyan}{magenta}Magenta{/magenta}{/bgcyan} '), end='')
print(Color('{bgcyan}{cyan}Cyan{/cyan}{/bgcyan} {bgcyan}{white}White{/white}{/bgcyan}'))
print(Color(' {bgwhite}{black}Black{/black}{/bgwhite} {bgwhite}{red}Red{/red}{/bgwhite} '), end='')
print(Color('{bgwhite}{green}Green{/green}{/bgwhite} {bgwhite}{yellow}Yellow{/yellow}{/bgwhite} '), end='')
print(Color('{bgwhite}{blue}Blue{/blue}{/bgwhite} {bgwhite}{magenta}Magenta{/magenta}{/bgwhite} '), end='')
print(Color('{bgwhite}{cyan}Cyan{/cyan}{/bgwhite} {bgwhite}{white}White{/white}{/bgwhite}'))
if OPTIONS['--wait']:
print('Waiting for {0} to exist within 10 seconds...'.format(OPTIONS['--wait']), file=sys.stderr, end='')
stop_after = time.time() + 20
while not os.path.exists(OPTIONS['--wait']) and time.time() < stop_after:
print('.', file=sys.stderr, end='')
sys.stderr.flush()
time.sleep(0.5)
print(' done') | [
"Main function called upon script execution."
] |
Please provide a description of the function:def angular_distance_fast(ra1, dec1, ra2, dec2):
lon1 = np.deg2rad(ra1)
lat1 = np.deg2rad(dec1)
lon2 = np.deg2rad(ra2)
lat2 = np.deg2rad(dec2)
dlon = lon2 - lon1
dlat = lat2 - lat1
a = np.sin(dlat/2.0)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon /2.0)**2
c = 2 * np.arcsin(np.sqrt(a))
return np.rad2deg(c) | [
"\n Compute angular distance using the Haversine formula. Use this one when you know you will never ask for points at\n their antipodes. If this is not the case, use the angular_distance function which is slower, but works also for\n antipodes.\n\n :param lon1:\n :param lat1:\n :param lon2:\n :param lat2:\n :return:\n "
] |
Please provide a description of the function:def angular_distance(ra1, dec1, ra2, dec2):
# Vincenty formula, slower than the Haversine formula in some cases, but stable also at antipodes
lon1 = np.deg2rad(ra1)
lat1 = np.deg2rad(dec1)
lon2 = np.deg2rad(ra2)
lat2 = np.deg2rad(dec2)
sdlon = np.sin(lon2 - lon1)
cdlon = np.cos(lon2 - lon1)
slat1 = np.sin(lat1)
slat2 = np.sin(lat2)
clat1 = np.cos(lat1)
clat2 = np.cos(lat2)
num1 = clat2 * sdlon
num2 = clat1 * slat2 - slat1 * clat2 * cdlon
denominator = slat1 * slat2 + clat1 * clat2 * cdlon
return np.rad2deg(np.arctan2(np.sqrt(num1 ** 2 + num2 ** 2), denominator)) | [
"\n Returns the angular distance between two points, two sets of points, or a set of points and one point.\n\n :param ra1: array or float, longitude of first point(s)\n :param dec1: array or float, latitude of first point(s)\n :param ra2: array or float, longitude of second point(s)\n :param dec2: array or float, latitude of second point(s)\n :return: angular distance(s) in degrees\n "
] |
Please provide a description of the function:def spherical_angle( ra0, dec0, ra1, dec1, ra2, dec2 ):
a = np.deg2rad( angular_distance(ra0, dec0, ra1, dec1))
b = np.deg2rad( angular_distance(ra0, dec0, ra2, dec2))
c = np.deg2rad( angular_distance(ra2, dec2, ra1, dec1))
#use the spherical law of cosines: https://en.wikipedia.org/wiki/Spherical_law_of_cosines#Rearrangements
numerator = np.atleast_1d( np.cos(c) - np.cos(a) * np.cos(b) )
denominator = np.atleast_1d( np.sin(a)*np.sin(b) )
return np.where( denominator == 0 , np.zeros( len(denominator)), np.rad2deg( np.arccos( numerator/denominator)) ) | [
"\n Returns the spherical angle distance between two sets of great circles defined by (ra0, dec0), (ra1, dec1) and (ra0, dec0), (ra2, dec2)\n\n :param ra0: array or float, longitude of intersection point(s)\n :param dec0: array or float, latitude of intersection point(s)\n :param ra1: array or float, longitude of first point(s)\n :param dec1: array or float, latitude of first point(s)\n :param ra2: array or float, longitude of second point(s)\n :param dec2: array or float, latitude of second point(s)\n :return: spherical angle in degrees\n "
] |
Please provide a description of the function:def use_astromodels_memoization(switch, cache_size=_CACHE_SIZE):
global _WITH_MEMOIZATION
global _CACHE_SIZE
old_status = bool(_WITH_MEMOIZATION)
old_cache_size = int(_CACHE_SIZE)
_WITH_MEMOIZATION = bool(switch)
_CACHE_SIZE = int(cache_size)
yield
_WITH_MEMOIZATION = old_status
_CACHE_SIZE = old_cache_size | [
"\n Activate/deactivate memoization temporarily\n\n :param switch: True (memoization on) or False (memoization off)\n :param cache_size: number of previous evaluation of functions to keep in memory. Default: 100\n :return:\n "
] |
Please provide a description of the function:def memoize(method):
cache = method.cache = collections.OrderedDict()
# Put these two methods in the local space (faster)
_get = cache.get
_popitem = cache.popitem
@functools.wraps(method)
def memoizer(instance, x, *args, **kwargs):
if not _WITH_MEMOIZATION or isinstance(x, u.Quantity):
# Memoization is not active or using units, do not use memoization
return method(instance, x, *args, **kwargs)
# Create a tuple because a tuple is hashable
unique_id = tuple(float(yy.value) for yy in instance.parameters.values()) + (x.size, x.min(), x.max())
# Create a unique identifier for this combination of inputs
key = hash(unique_id)
# Let's do it this way so we only look into the dictionary once
result = _get(key)
if result is not None:
return result
else:
result = method(instance, x, *args, **kwargs)
cache[key] = result
if len(cache) > _CACHE_SIZE:
# Remove half of the element (but at least 1, even if _CACHE_SIZE=1, which would be pretty idiotic ;-) )
[_popitem(False) for i in range(max(_CACHE_SIZE // 2, 1))]
return result
# Add the function as a "attribute" so we can access it
memoizer.input_object = method
return memoizer | [
"\n A decorator for functions of sources which memoize the results of the last _CACHE_SIZE calls,\n\n :param method: method to be memoized\n :return: the decorated method\n "
] |
Please provide a description of the function:def xspec_cosmo(H0=None,q0=None,lambda_0=None):
current_settings = _xspec.get_xscosmo()
if (H0 is None) and (q0 is None) and (lambda_0 is None):
return current_settings
else:
# ok, we will see what was changed by the used
user_inputs = [H0, q0, lambda_0]
for i, current_setting in enumerate(current_settings):
if user_inputs[i] is None:
# the user didn't modify this,
# so lets keep what was already set
user_inputs[i] = current_setting
# pass this to xspec
_xspec.set_xscosmo(*user_inputs) | [
"\n Define the Cosmology in use within the XSpec models. See Xspec manual for help:\n\n http://heasarc.nasa.gov/xanadu/xspec/manual/XScosmo.html\n \n All parameters can be modified or just a single parameter\n\n :param H0: the hubble constant\n :param q0:\n :param lambda_0:\n :return: Either none or the current setting (H_0, q_0, lambda_0)\n "
] |
Please provide a description of the function:def find_model_dat():
# model.dat is in $HEADAS/../spectral
headas_env = os.environ.get("HEADAS")
assert headas_env is not None, ("You need to setup the HEADAS variable before importing this module."
" See Heasoft documentation.")
# Expand all variables and other things like ~
headas_env = os.path.expandvars(os.path.expanduser(headas_env))
# Lazy check that it exists
assert os.path.exists(headas_env), "The HEADAS env. variable point to a non-existent directory: %s" % (headas_env)
# Get one directory above HEADAS (i.e., $HEADAS/..)
inferred_path = os.path.dirname(headas_env)
# Now model.dat should be in $HEADAS/../spectral/manager
final_path = os.path.join(inferred_path, 'spectral', 'manager', 'model.dat')
# Check that model.dat exists
assert os.path.exists(final_path), "Cannot find Xspec model definition file %s" % (final_path)
return os.path.abspath(final_path) | [
"\n Find the file containing the definition of all the models in Xspec\n (model.dat) and return its path\n "
] |
Please provide a description of the function:def get_models(model_dat_path):
# Check first if we already have a model data file in the data directory
with open(model_dat_path) as f:
# model.dat is a text file, no size issues here (will fit in memory)
model_dat = f.read()
# Replace \r or \r\n with \n (the former two might be in the file if
# it originates from Windows)
if "\n" in model_dat:
model_dat = model_dat.replace("\r", "")
else:
model_dat = model_dat.replace("\r", "\n")
# Loop through the file and build the model definition
# dictionary
lines = model_dat.split("\n")
model_definitions = collections.OrderedDict()
for line in lines:
match = re.match('''(.+(add|mul|con|acn).+)''', line)
if match is not None:
# This is a model definition
tokens = line.split()
if len(tokens) == 7:
(model_name, n_parameters,
min_energy, max_energy,
library_function,
model_type,
flag) = line.split()
else:
(model_name, n_parameters,
min_energy, max_energy,
library_function,
model_type,
flag,
flag_2) = line.split()
this_model = collections.OrderedDict()
this_model['description'] = 'The %s model from XSpec (https://heasarc.gsfc.nasa.gov/xanadu/' \
'xspec/manual/XspecModels.html)' % model_name
this_model['parameters'] = collections.OrderedDict()
model_definitions[(model_name, library_function, model_type)] = this_model
else:
# This is a parameter definition
if len(line.split()) == 0:
# Empty line
continue
# Parameters are free by default, unless they have delta < 0
# they are switch parameters or scale parameters
free = True
if line[0] == '$':
# Probably a switch parameter
free = False
tokens = line.split()
if len(tokens) == 2:
par_name = tokens[0][1:]
default_value = tokens[1]
par_unit = ""
hard_minimum, soft_minimum, soft_maximum, hard_maximum = (0, 0, 1e9, 1e9)
elif len(tokens) == 3:
par_name = tokens[0][1:]
default_value = tokens[2]
par_unit = ""
hard_minimum, soft_minimum, soft_maximum, hard_maximum = (0, 0, 1e9, 1e9)
else:
match = re.match('(\S+)\s+(\".+\"|[a-zA-Z]+)?(.+)*', line[1:])
par_name, par_unit, par_spec = match.groups()
tokens = par_spec.split()
if len(tokens) == 1:
default_value = tokens[0]
par_unit = ""
hard_minimum, soft_minimum, soft_maximum, hard_maximum = (0, 0, 1e9, 1e9)
else:
par_unit = ""
(default_value,
hard_minimum, soft_minimum,
soft_maximum, hard_maximum,
delta) = par_spec.split()
else:
# A normal parameter
match = re.match('(\S+)\s+(\".+\"|\S+)(.+)', line)
if match is None:
raise RuntimeError("Cannot parse parameter %s" % line)
par_name, par_unit, par_spec = match.groups()
if par_name[0] == '*':
# Scale parameter (always frozen)
par_name = par_name[1:]
free = False
tokens = par_spec.split()
if len(tokens) == 1:
default_value = tokens[0]
(hard_minimum, soft_minimum,
soft_maximum, hard_maximum,
delta) = (None, None, None, None, 0.1)
else:
(default_value,
hard_minimum, soft_minimum,
soft_maximum, hard_maximum,
delta) = par_spec.split()
delta = abs(float(delta))
else:
(default_value,
hard_minimum, soft_minimum,
soft_maximum, hard_maximum,
delta) = par_spec.split()
delta = float(delta)
if delta <= 0:
free = False
delta = abs(delta)
# Now fix the parameter name removing illegal characters
# (for example 'log(A)' is not a legal name)
par_name = re.sub('[\(,\)]', '_', par_name)
par_name = re.sub('<', '_less_', par_name)
par_name = re.sub('>', '_more_', par_name)
par_name = re.sub('/', '_div_', par_name)
par_name = re.sub('\-', '_minus_', par_name)
par_name = re.sub('\+', '_plus_', par_name)
par_name = re.sub('\.', '_dot_', par_name)
par_name = re.sub('@', '_at_', par_name)
# Parameter names must be lower case
par_name = par_name.lower()
# Some parameters are enclosed between ", like "z"
par_name = par_name.replace('"', '')
# "z" is a protected name in astromodels.
if par_name == "z":
par_name = "redshift"
# Check that the parameter name is not an illegal Python name
if par_name in illegal_variable_names:
par_name = "xs_%s" % par_name
# Sometimes the unit is " " which is not recognized by astropy
if par_unit:
par_unit = par_unit.replace("\"",'')
# There are some errors in model.dat , like KeV instead of keV, and ergcm/s instead of erg cm /s
# Let's correct them
if par_unit == "KeV":
par_unit = "keV"
elif par_unit == "ergcm/s":
par_unit = "erg cm / s"
elif par_unit == "days":
par_unit = "day"
elif par_unit == "z" and par_name.lower() == "redshift":
par_unit = ""
# There are funny units in model.dat, like "Rs" (which means Schwarzschild radius) or other things
# so let's try to convert the par_unit into an astropy.Unit instance. If that fails, use a unitless unit
try:
_ = u.Unit(par_unit)
except ValueError:
# Unit not recognized
#warnings.warn("Unit %s is not recognized by astropy." % par_unit)
par_unit = ''
# Make sure that this is a valid python identifier
# by matching it with the relative regexp
if re.match('([a-zA-Z_][a-zA-Z0-9_]*)$', par_name) is None:
raise ValueError("Illegal identifier name %s" % (par_name))
this_model['parameters'][par_name] = {'initial value': float(default_value),
'desc': '(see https://heasarc.gsfc.nasa.gov/xanadu/xspec/manual/'
'XspecModels.html)',
'min': hard_minimum,
'max': hard_maximum,
'delta': float(delta),
'unit': par_unit,
'free': free}
return model_definitions | [
"\n Parse the model.dat file from Xspec and returns a dictionary containing the definition of all the models\n\n :param model_dat_path: the path to the model.dat file\n :return: dictionary containing the definition of all XSpec models\n "
] |
Please provide a description of the function:def _add_source(self, source):
try:
self._add_child(source)
except AttributeError:
if isinstance(source, Source):
raise DuplicatedNode("More than one source with the name '%s'. You cannot use the same name for multiple "
"sources" % source.name)
else: # pragma: no cover
raise
# Now see if this is a point or extended source, and add them to the
# appropriate dictionary
if source.source_type == POINT_SOURCE:
self._point_sources[source.name] = source
elif source.source_type == EXTENDED_SOURCE:
self._extended_sources[source.name] = source
elif source.source_type == PARTICLE_SOURCE:
self._particle_sources[source.name] = source
else: # pragma: no cover
raise InvalidInput("Input sources must be either a point source or an extended source") | [
"\n Remember to call _update_parameters after this!\n :param source:\n :return:\n "
] |
Please provide a description of the function:def _remove_source(self, source_name):
assert source_name in self.sources, "Source %s is not part of the current model" % source_name
source = self.sources.pop(source_name)
if source.source_type == POINT_SOURCE:
self._point_sources.pop(source.name)
elif source.source_type == EXTENDED_SOURCE:
self._extended_sources.pop(source.name)
elif source.source_type == PARTICLE_SOURCE:
self._particle_sources.pop(source.name)
self._remove_child(source_name) | [
"\n Remember to call _update_parameters after this\n :param source_name:\n :return:\n "
] |
Please provide a description of the function:def free_parameters(self):
# Refresh the list
self._update_parameters()
# Filter selecting only free parameters
free_parameters_dictionary = collections.OrderedDict()
for parameter_name, parameter in self._parameters.iteritems():
if parameter.free:
free_parameters_dictionary[parameter_name] = parameter
return free_parameters_dictionary | [
"\n Get a dictionary with all the free parameters in this model\n\n :return: dictionary of free parameters\n "
] |
Please provide a description of the function:def linked_parameters(self):
# Refresh the list
self._update_parameters()
# Filter selecting only free parameters
linked_parameter_dictionary = collections.OrderedDict()
for parameter_name, parameter in self._parameters.iteritems():
if parameter.has_auxiliary_variable():
linked_parameter_dictionary[parameter_name] = parameter
return linked_parameter_dictionary | [
"\n Get a dictionary with all parameters in this model in a linked status. A parameter is in a linked status\n if it is linked to another parameter (i.e. it is forced to have the same value of the other parameter), or\n if it is linked with another parameter or an independent variable through a law.\n\n :return: dictionary of linked parameters\n "
] |
Please provide a description of the function:def set_free_parameters(self, values):
assert len(values) == len(self.free_parameters)
for parameter, this_value in zip(self.free_parameters.values(), values):
parameter.value = this_value | [
"\n Set the free parameters in the model to the provided values.\n\n NOTE: of course, order matters\n\n :param values: a list of new values\n :return: None\n "
] |
Please provide a description of the function:def sources(self):
sources = collections.OrderedDict()
for d in (self.point_sources, self.extended_sources, self.particle_sources):
sources.update(d)
return sources | [
"\n Returns a dictionary containing all defined sources (of any kind)\n\n :return: collections.OrderedDict()\n\n "
] |
Please provide a description of the function:def add_independent_variable(self, variable):
assert isinstance(variable, IndependentVariable), "Variable must be an instance of IndependentVariable"
if self._has_child(variable.name):
self._remove_child(variable.name)
self._add_child(variable)
# Add also to the list of independent variables
self._independent_variables[variable.name] = variable | [
"\n Add a global independent variable to this model, such as time.\n\n :param variable: an IndependentVariable instance\n :return: none\n "
] |
Please provide a description of the function:def remove_independent_variable(self, variable_name):
self._remove_child(variable_name)
# Remove also from the list of independent variables
self._independent_variables.pop(variable_name) | [
"\n Remove an independent variable which was added with add_independent_variable\n\n :param variable_name: name of variable to remove\n :return:\n "
] |
Please provide a description of the function:def add_external_parameter(self, parameter):
assert isinstance(parameter, Parameter), "Variable must be an instance of IndependentVariable"
if self._has_child(parameter.name):
# Remove it from the children only if it is a Parameter instance, otherwise don't, which will
# make the _add_child call fail (which is the expected behaviour! You shouldn't call two children
# with the same name)
if isinstance(self._get_child(parameter.name), Parameter):
warnings.warn("External parameter %s already exist in the model. Overwriting it..." % parameter.name,
RuntimeWarning)
self._remove_child(parameter.name)
# This will fail if another node with the same name is already in the model
self._add_child(parameter) | [
"\n Add a parameter that comes from something other than a function, to the model.\n\n :param parameter: a Parameter instance\n :return: none\n "
] |
Please provide a description of the function:def link(self, parameter_1, parameter_2, link_function=None):
if not isinstance(parameter_1,list):
# Make a list of one element
parameter_1_list = [parameter_1]
else:
# Make a copy to avoid tampering with the input
parameter_1_list = list(parameter_1)
for param_1 in parameter_1_list:
assert param_1.path in self, "Parameter %s is not contained in this model" % param_1.path
assert parameter_2.path in self, "Parameter %s is not contained in this model" % parameter_2.path
if link_function is None:
# Use the Line function by default, with both parameters fixed so that the two
# parameters to be linked will vary together
link_function = get_function('Line')
link_function.a.value = 1
link_function.a.fix = True
link_function.b.value = 0
link_function.b.fix = True
for param_1 in parameter_1_list:
param_1.add_auxiliary_variable(parameter_2, link_function)
# Now set the units of the link function
link_function.set_units(parameter_2.unit, param_1.unit) | [
"\n Link the value of the provided parameters through the provided function (identity is the default, i.e.,\n parameter_1 = parameter_2).\n\n :param parameter_1: the first parameter;can be either a single parameter or a list of prarameters\n :param parameter_2: the second parameter\n :param link_function: a function instance. If not provided, the identity function will be used by default.\n Otherwise, this link will be set: parameter_1 = link_function(parameter_2)\n :return: (none)\n "
] |
Please provide a description of the function:def unlink(self, parameter):
if not isinstance(parameter,list):
# Make a list of one element
parameter_list = [parameter]
else:
# Make a copy to avoid tampering with the input
parameter_list = list(parameter)
for param in parameter_list:
if param.has_auxiliary_variable():
param.remove_auxiliary_variable()
else:
with warnings.catch_warnings():
warnings.simplefilter("always", RuntimeWarning)
warnings.warn("Parameter %s has no link to be removed." % param.path, RuntimeWarning) | [
"\n Sets free one or more parameters which have been linked previously\n\n :param parameter: the parameter to be set free, can also be a list of parameters\n :return: (none)\n "
] |
Please provide a description of the function:def display(self, complete=False):
# Switch on the complete display flag
self._complete_display = bool(complete)
# This will automatically choose the best representation among repr and repr_html
super(Model, self).display()
# Go back to default
self._complete_display = False | [
"\n Display information about the point source.\n\n :param complete : if True, displays also information on fixed parameters\n :return: (none)\n "
] |
Please provide a description of the function:def save(self, output_file, overwrite=False):
if os.path.exists(output_file) and overwrite is False:
raise ModelFileExists("The file %s exists already. If you want to overwrite it, use the 'overwrite=True' "
"options as 'model.save(\"%s\", overwrite=True)'. " % (output_file, output_file))
else:
data = self.to_dict_with_types()
# Write it to disk
try:
# Get the YAML representation of the data
representation = my_yaml.dump(data, default_flow_style=False)
with open(output_file, "w+") as f:
# Add a new line at the end of each voice (just for clarity)
f.write(representation.replace("\n", "\n\n"))
except IOError:
raise CannotWriteModel(os.path.dirname(os.path.abspath(output_file)),
"Could not write model file %s. Check your permissions to write or the "
"report on the free space which follows: " % output_file) | [
"Save the model to disk"
] |
Please provide a description of the function:def get_point_source_position(self, id):
pts = self._point_sources.values()[id]
return pts.position.get_ra(), pts.position.get_dec() | [
"\n Get the point source position (R.A., Dec)\n\n :param id: id of the source\n :return: a tuple with R.A. and Dec.\n "
] |
Please provide a description of the function:def get_point_source_fluxes(self, id, energies, tag=None):
return self._point_sources.values()[id](energies, tag=tag) | [
"\n Get the fluxes from the id-th point source\n\n :param id: id of the source\n :param energies: energies at which you need the flux\n :param tag: a tuple (integration variable, a, b) specifying the integration to perform. If this\n parameter is specified then the returned value will be the average flux for the source computed as the integral\n between a and b over the integration variable divided by (b-a). The integration variable must be an independent\n variable contained in the model. If b is None, then instead of integrating the integration variable will be\n set to a and the model evaluated in a.\n :return: fluxes\n "
] |
Please provide a description of the function:def get_extended_source_fluxes(self, id, j2000_ra, j2000_dec, energies):
return self._extended_sources.values()[id](j2000_ra, j2000_dec, energies) | [
"\n Get the flux of the id-th extended sources at the given position at the given energies\n\n :param id: id of the source\n :param j2000_ra: R.A. where the flux is desired\n :param j2000_dec: Dec. where the flux is desired\n :param energies: energies at which the flux is desired\n :return: flux array\n "
] |
Please provide a description of the function:def get_total_flux(self, energies):
fluxes = []
for src in self._point_sources:
fluxes.append(self._point_sources[src](energies))
return np.sum(fluxes, axis=0) | [
"\n Returns the total differential flux at the provided energies from all *point* sources\n\n :return:\n "
] |
Please provide a description of the function:def long_path_formatter(line, max_width=pd.get_option('max_colwidth')):
if len(line) > max_width:
tokens = line.split(".")
trial1 = "%s...%s" % (tokens[0], tokens[-1])
if len(trial1) > max_width:
return "...%s" %(tokens[-1][-1:-(max_width-3)])
else:
return trial1
else:
return line | [
"\n If a path is longer than max_width, it substitute it with the first and last element,\n joined by \"...\". For example 'this.is.a.long.path.which.we.want.to.shorten' becomes\n 'this...shorten'\n\n :param line:\n :param max_width:\n :return:\n "
] |
Please provide a description of the function:def has_free_parameters(self):
for component in self._components.values():
for par in component.shape.parameters.values():
if par.free:
return True
for par in self.position.parameters.values():
if par.free:
return True
return False | [
"\n Returns True or False whether there is any parameter in this source\n\n :return:\n "
] |
Please provide a description of the function:def free_parameters(self):
free_parameters = collections.OrderedDict()
for component in self._components.values():
for par in component.shape.parameters.values():
if par.free:
free_parameters[par.path] = par
for par in self.position.parameters.values():
if par.free:
free_parameters[par.path] = par
return free_parameters | [
"\n Returns a dictionary of free parameters for this source.\n We use the parameter path as the key because it's \n guaranteed to be unique, unlike the parameter name.\n\n :return:\n "
] |
Please provide a description of the function:def parameters(self):
all_parameters = collections.OrderedDict()
for component in self._components.values():
for par in component.shape.parameters.values():
all_parameters[par.path] = par
for par in self.position.parameters.values():
all_parameters[par.path] = par
return all_parameters | [
"\n Returns a dictionary of all parameters for this source.\n We use the parameter path as the key because it's \n guaranteed to be unique, unlike the parameter name.\n\n :return:\n "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.