text_prompt stringlengths 157 13.1k | code_prompt stringlengths 7 19.8k ⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def toList(self):
""" Returns date as signed list. """ |
date = self.date()
sign = '+' if date[0] >= 0 else '-'
date[0] = abs(date[0])
return list(sign) + date |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def toString(self):
""" Returns date as string. """ |
slist = self.toList()
sign = '' if slist[0] == '+' else '-'
string = '/'.join(['%02d' % v for v in slist[1:]])
return sign + string |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getUTC(self, utcoffset):
""" Returns a new Time object set to UTC given an offset Time object. """ |
newTime = (self.value - utcoffset.value) % 24
return Time(newTime) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def toList(self):
""" Returns time as signed list. """ |
slist = angle.toList(self.value)
# Keep hours in 0..23
slist[1] = slist[1] % 24
return slist |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def toString(self):
""" Returns time as string. """ |
slist = self.toList()
string = angle.slistStr(slist)
return string if slist[0] == '-' else string[1:] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fromJD(jd, utcoffset):
""" Builds a Datetime object given a jd and utc offset. """ |
if not isinstance(utcoffset, Time):
utcoffset = Time(utcoffset)
localJD = jd + utcoffset.value / 24.0
date = Date(round(localJD))
time = Time((localJD + 0.5 - date.jdn) * 24)
return Datetime(date, time, utcoffset) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getUTC(self):
""" Returns this Datetime localized for UTC. """ |
timeUTC = self.time.getUTC(self.utcoffset)
dateUTC = Date(round(self.jd))
return Datetime(dateUTC, timeUTC) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getObject(ID, jd, lat, lon):
""" Returns an object for a specific date and location. """ |
if ID == const.SOUTH_NODE:
obj = swe.sweObject(const.NORTH_NODE, jd)
obj.update({
'id': const.SOUTH_NODE,
'lon': angle.norm(obj['lon'] + 180)
})
elif ID == const.PARS_FORTUNA:
pflon = tools.pfLon(jd, lat, lon)
obj = {
'id': ID,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getFixedStar(ID, jd):
""" Returns a fixed star. """ |
star = swe.sweFixedStar(ID, jd)
_signInfo(star)
return star |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def nextSunrise(jd, lat, lon):
""" Returns the JD of the next sunrise. """ |
return swe.sweNextTransit(const.SUN, jd, lat, lon, 'RISE') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def nextSunset(jd, lat, lon):
""" Returns the JD of the next sunset. """ |
return swe.sweNextTransit(const.SUN, jd, lat, lon, 'SET') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _signInfo(obj):
""" Appends the sign id and longitude to an object. """ |
lon = obj['lon']
obj.update({
'sign': const.LIST_SIGNS[int(lon / 30)],
'signlon': lon % 30
}) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pfLon(jd, lat, lon):
""" Returns the ecliptic longitude of Pars Fortuna. It considers diurnal or nocturnal conditions. """ |
sun = swe.sweObjectLon(const.SUN, jd)
moon = swe.sweObjectLon(const.MOON, jd)
asc = swe.sweHousesLon(jd, lat, lon,
const.HOUSES_DEFAULT)[1][0]
if isDiurnal(jd, lat, lon):
return angle.norm(asc + moon - sun)
else:
return angle.norm(asc + sun - moon) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def isDiurnal(jd, lat, lon):
""" Returns true if the sun is above the horizon of a given date and location. """ |
sun = swe.sweObject(const.SUN, jd)
mc = swe.sweHousesLon(jd, lat, lon,
const.HOUSES_DEFAULT)[1][1]
ra, decl = utils.eqCoords(sun['lon'], sun['lat'])
mcRA, _ = utils.eqCoords(mc, 0.0)
return utils.isAboveHorizon(ra, decl, mcRA, lat) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def syzygyJD(jd):
""" Finds the latest new or full moon and returns the julian date of that event. """ |
sun = swe.sweObjectLon(const.SUN, jd)
moon = swe.sweObjectLon(const.MOON, jd)
dist = angle.distance(sun, moon)
# Offset represents the Syzygy type.
# Zero is conjunction and 180 is opposition.
offset = 180 if (dist >= 180) else 0
while abs(dist) > MAX_ERROR:
jd = jd - dist / 1... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def solarReturnJD(jd, lon, forward=True):
""" Finds the julian date before or after 'jd' when the sun is at longitude 'lon'. It searches forward by default. """ |
sun = swe.sweObjectLon(const.SUN, jd)
if forward:
dist = angle.distance(sun, lon)
else:
dist = -angle.distance(lon, sun)
while abs(dist) > MAX_ERROR:
jd = jd + dist / 0.9833 # Sun mean motion
sun = swe.sweObjectLon(const.SUN, jd)
dist = angle.closestdis... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def nextStationJD(ID, jd):
""" Finds the aproximate julian date of the next station of a planet. """ |
speed = swe.sweObject(ID, jd)['lonspeed']
for i in range(2000):
nextjd = jd + i / 2
nextspeed = swe.sweObject(ID, nextjd)['lonspeed']
if speed * nextspeed <= 0:
return nextjd
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def clean_caches(path):
""" Removes all python cache files recursively on a path. :param path: the path :return: None """ |
for dirname, subdirlist, filelist in os.walk(path):
for f in filelist:
if f.endswith('pyc'):
try:
os.remove(os.path.join(dirname, f))
except FileNotFoundError:
pass
if dirname.endswith('__pycache__'):
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def clean_py_files(path):
""" Removes all .py files. :param path: the path :return: None """ |
for dirname, subdirlist, filelist in os.walk(path):
for f in filelist:
if f.endswith('py'):
os.remove(os.path.join(dirname, f)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _orbList(obj1, obj2, aspList):
""" Returns a list with the orb and angular distances from obj1 to obj2, considering a list of possible aspects. """ |
sep = angle.closestdistance(obj1.lon, obj2.lon)
absSep = abs(sep)
return [
{
'type': asp,
'orb': abs(absSep - asp),
'separation': sep,
} for asp in aspList
] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _aspectProperties(obj1, obj2, aspDict):
""" Returns the properties of an aspect between obj1 and obj2, given by 'aspDict'. This function assumes obj1 to be t... |
orb = aspDict['orb']
asp = aspDict['type']
sep = aspDict['separation']
# Properties
prop1 = {
'id': obj1.id,
'inOrb': False,
'movement': const.NO_MOVEMENT
}
prop2 = {
'id': obj2.id,
'inOrb': False,
'movement': const.NO_MOVEMENT ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _getActivePassive(obj1, obj2):
""" Returns which is the active and the passive objects. """ |
speed1 = abs(obj1.lonspeed) if obj1.isPlanet() else -1.0
speed2 = abs(obj2.lonspeed) if obj2.isPlanet() else -1.0
if speed1 > speed2:
return {
'active': obj1,
'passive': obj2
}
else:
return {
'active': obj2,
'passive': obj1
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def aspectType(obj1, obj2, aspList):
""" Returns the aspect type between objects considering a list of possible aspect types. """ |
ap = _getActivePassive(obj1, obj2)
aspDict = _aspectDict(ap['active'], ap['passive'], aspList)
return aspDict['type'] if aspDict else const.NO_ASPECT |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def hasAspect(obj1, obj2, aspList):
""" Returns if there is an aspect between objects considering a list of possible aspect types. """ |
aspType = aspectType(obj1, obj2, aspList)
return aspType != const.NO_ASPECT |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def isAspecting(obj1, obj2, aspList):
""" Returns if obj1 aspects obj2 within its orb, considering a list of possible aspect types. """ |
aspDict = _aspectDict(obj1, obj2, aspList)
if aspDict:
return aspDict['orb'] < obj1.orb()
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getAspect(obj1, obj2, aspList):
""" Returns an Aspect object for the aspect between two objects considering a list of possible aspect types. """ |
ap = _getActivePassive(obj1, obj2)
aspDict = _aspectDict(ap['active'], ap['passive'], aspList)
if not aspDict:
aspDict = {
'type': const.NO_ASPECT,
'orb': 0,
'separation': 0,
}
aspProp = _aspectProperties(ap['active'], ap['passive'], aspDict)
ret... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def movement(self):
""" Returns the movement of this aspect. The movement is the one of the active object, except if the active is separating but within less tha... |
mov = self.active.movement
if self.orb < 1 and mov == const.SEPARATIVE:
mov = const.EXACT
return mov |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def setFaces(variant):
""" Sets the default faces variant """ |
global FACES
if variant == CHALDEAN_FACES:
FACES = tables.CHALDEAN_FACES
else:
FACES = tables.TRIPLICITY_FACES |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def setTerms(variant):
""" Sets the default terms of the Dignities table. """ |
global TERMS
if variant == EGYPTIAN_TERMS:
TERMS = tables.EGYPTIAN_TERMS
elif variant == TETRABIBLOS_TERMS:
TERMS = tables.TETRABIBLOS_TERMS
elif variant == LILLY_TERMS:
TERMS = tables.LILLY_TERMS |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def term(sign, lon):
""" Returns the term for a sign and longitude. """ |
terms = TERMS[sign]
for (ID, a, b) in terms:
if (a <= lon < b):
return ID
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def face(sign, lon):
""" Returns the face for a sign and longitude. """ |
faces = FACES[sign]
if lon < 10:
return faces[0]
elif lon < 20:
return faces[1]
else:
return faces[2] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getInfo(sign, lon):
""" Returns the complete essential dignities for a sign and longitude. """ |
return {
'ruler': ruler(sign),
'exalt': exalt(sign),
'dayTrip': dayTrip(sign),
'nightTrip': nightTrip(sign),
'partTrip': partTrip(sign),
'term': term(sign, lon),
'face': face(sign, lon),
'exile': exile(sign),
'fall': fall(sign)
} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def isPeregrine(ID, sign, lon):
""" Returns if an object is peregrine on a sign and longitude. """ |
info = getInfo(sign, lon)
for dign, objID in info.items():
if dign not in ['exile', 'fall'] and ID == objID:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def score(ID, sign, lon):
""" Returns the score of an object on a sign and longitude. """ |
info = getInfo(sign, lon)
dignities = [dign for (dign, objID) in info.items() if objID == ID]
return sum([SCORES[dign] for dign in dignities]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def almutem(sign, lon):
""" Returns the almutem for a given sign and longitude. """ |
planets = const.LIST_SEVEN_PLANETS
res = [None, 0]
for ID in planets:
sc = score(ID, sign, lon)
if sc > res[1]:
res = [ID, sc]
return res[0] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getDignities(self):
""" Returns the dignities belonging to this object. """ |
info = self.getInfo()
dignities = [dign for (dign, objID) in info.items()
if objID == self.obj.id]
return dignities |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def isPeregrine(self):
""" Returns if this object is peregrine. """ |
return isPeregrine(self.obj.id,
self.obj.sign,
self.obj.signlon) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _computeChart(chart, date):
""" Internal function to return a new chart for a specific date using properties from old chart. """ |
pos = chart.pos
hsys = chart.hsys
IDs = [obj.id for obj in chart.objects]
return Chart(date, pos, IDs=IDs, hsys=hsys) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def nextSolarReturn(chart, date):
""" Returns the solar return of a Chart after a specific date. """ |
sun = chart.getObject(const.SUN)
srDate = ephem.nextSolarReturn(date, sun.lon)
return _computeChart(chart, srDate) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getHourTable(date, pos):
""" Returns an HourTable object. """ |
table = hourTable(date, pos)
return HourTable(table, date) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def index(self, date):
""" Returns the index of a date in the table. """ |
for (i, (start, end, ruler)) in enumerate(self.table):
if start <= date.jd <= end:
return i
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def indexInfo(self, index):
""" Returns information about a specific planetary time. """ |
entry = self.table[index]
info = {
# Default is diurnal
'mode': 'Day',
'ruler': self.dayRuler(),
'dayRuler': self.dayRuler(),
'nightRuler': self.nightRuler(),
'hourRuler': entry[2],
'hourNumber': index + 1,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compute(chart, date, fixedObjects=False):
""" Returns a profection chart for a given date. Receives argument 'fixedObjects' to fix chart objects in their nat... |
sun = chart.getObject(const.SUN)
prevSr = ephem.prevSolarReturn(date, sun.lon)
nextSr = ephem.nextSolarReturn(date, sun.lon)
# In one year, rotate chart 30º
rotation = 30 * (date.jd - prevSr.jd) / (nextSr.jd - prevSr.jd)
# Include 30º for each previous year
age = math.floor((... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _merge(listA, listB):
""" Merges two list of objects removing repetitions. """ |
listA = [x.id for x in listA]
listB = [x.id for x in listB]
listA.extend(listB)
set_ = set(listA)
return list(set_) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compute(chart):
""" Computes the behavior. """ |
factors = []
# Planets in House1 or Conjunct Asc
house1 = chart.getHouse(const.HOUSE1)
planetsHouse1 = chart.objects.getObjectsInHouse(house1)
asc = chart.getAngle(const.ASC)
planetsConjAsc = chart.objects.getObjectsAspecting(asc, [0])
_set = _merge(planetsHouse1, planetsConj... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def termLons(TERMS):
""" Returns a list with the absolute longitude of all terms. """ |
res = []
for i, sign in enumerate(SIGN_LIST):
termList = TERMS[sign]
res.extend([
ID,
sign,
start + 30 * i,
] for (ID, start, end) in termList)
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compute(chart):
""" Computes the Almutem table. """ |
almutems = {}
# Hylegic points
hylegic = [
chart.getObject(const.SUN),
chart.getObject(const.MOON),
chart.getAngle(const.ASC),
chart.getObject(const.PARS_FORTUNA),
chart.getObject(const.SYZYGY)
]
for hyleg in hylegic:
row = newRow()
digIn... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get(self, resource_id=None, resource_action=None, resource_cls=None, single_resource=False):
""" Gets the details for one or more resources by ID Args: cls -... |
endpoint = self.endpoint
if not resource_cls:
resource_cls = self._cls
if resource_id:
endpoint = self._build_url(endpoint, resource_id)
if resource_action:
endpoint = self._build_url(endpoint, resource_action)
response = self.api.execute... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def post(self, resource):
""" Creates a new instance of the resource. Args: resource - gophish.models.Model - The resource instance """ |
response = self.api.execute(
"POST", self.endpoint, json=(resource.as_dict()))
if not response.ok:
raise Error.parse(response.json())
return self._cls.parse(response.json()) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def put(self, resource):
""" Edits an existing resource Args: resource - gophish.models.Model - The resource instance """ |
endpoint = self.endpoint
if resource.id:
endpoint = self._build_url(endpoint, resource.id)
response = self.api.execute("PUT", endpoint, json=resource.as_dict())
if not response.ok:
raise Error.parse(response.json())
return self._cls.parse(response.js... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete(self, resource_id):
""" Deletes an existing resource Args: resource_id - int - The resource ID to be deleted """ |
endpoint = '{}/{}'.format(self.endpoint, resource_id)
response = self.api.execute("DELETE", endpoint)
if not response.ok:
raise Error.parse(response.json())
return self._cls.parse(response.json()) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def as_dict(self):
""" Returns a dict representation of the resource """ |
result = {}
for key in self._valid_properties:
val = getattr(self, key)
if isinstance(val, datetime):
val = val.isoformat()
# Parse custom classes
elif val and not Model._is_builtin(val):
val = val.as_dict()
# P... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute(self, method, path, **kwargs):
""" Executes a request to a given endpoint, returning the result """ |
url = "{}{}".format(self.host, path)
kwargs.update(self._client_kwargs)
response = requests.request(
method,
url,
headers={"Authorization": "Bearer {}".format(self.api_key)},
**kwargs)
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def summary(self, campaign_id=None):
""" Returns the campaign summary """ |
resource_cls = CampaignSummary
single_resource = False
if not campaign_id:
resource_cls = CampaignSummaries
single_resource = True
return super(API, self).get(
resource_id=campaign_id,
resource_action='summary',
resource_cls=... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def results(self, campaign_id):
""" Returns just the results for a given campaign """ |
return super(API, self).get(
resource_id=campaign_id,
resource_action='results',
resource_cls=CampaignResults) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_path(self, file_path):
""" Set the path of the database. Create the file if it does not exist. """ |
if not file_path:
self.read_data = self.memory_read
self.write_data = self.memory_write
elif not is_valid(file_path):
self.write_data(file_path, {})
self.path = file_path |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete(self, key):
""" Removes the specified key from the database. """ |
obj = self._get_content()
obj.pop(key, None)
self.write_data(self.path, obj) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data(self, **kwargs):
""" If a key is passed in, a corresponding value will be returned. If a key-value pair is passed in then the corresponding key in the d... |
key = kwargs.pop('key', None)
value = kwargs.pop('value', None)
dictionary = kwargs.pop('dictionary', None)
# Fail if a key and a dictionary or a value and a dictionary are given
if (key is not None and dictionary is not None) or \
(value is not None and dictionary ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def filter(self, filter_arguments):
""" Takes a dictionary of filter parameters. Return a list of objects based on a list of parameters. """ |
results = self._get_content()
# Filter based on a dictionary of search parameters
if isinstance(filter_arguments, dict):
for item, content in iteritems(self._get_content()):
for key, value in iteritems(filter_arguments):
keys = key.split('.')
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def drop(self):
""" Remove the database by deleting the JSON file. """ |
import os
if self.path:
if os.path.exists(self.path):
os.remove(self.path)
else:
# Clear the in-memory data if there is no file path
self._data = {} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_data(file_path):
""" Reads a file and returns a json encoded representation of the file. """ |
if not is_valid(file_path):
write_data(file_path, {})
db = open_file_for_reading(file_path)
content = db.read()
obj = decode(content)
db.close()
return obj |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_data(path, obj):
""" Writes to a file and returns the updated file content. """ |
with open_file_for_writing(path) as db:
db.write(encode(obj))
return obj |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_valid(file_path):
""" Check to see if a file exists or is empty. """ |
from os import path, stat
can_open = False
try:
with open(file_path) as fp:
can_open = True
except IOError:
return False
is_file = path.isfile(file_path)
return path.exists(file_path) and is_file and stat(file_path).st_size > 0 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_edges(cells_nodes):
"""Setup edge-node and edge-cell relations. Adapted from voropy. """ |
# Create the idx_hierarchy (nodes->edges->cells), i.e., the value of
# `self.idx_hierarchy[0, 2, 27]` is the index of the node of cell 27, edge
# 2, node 0. The shape of `self.idx_hierarchy` is `(2, 3, n)`, where `n` is
# the number of cells. Make sure that the k-th edge is opposite of the k-th
# p... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def plot2d(points, cells, mesh_color="k", show_axes=False):
"""Plot a 2D mesh using matplotlib. """ |
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection
fig = plt.figure()
ax = fig.gca()
plt.axis("equal")
if not show_axes:
ax.set_axis_off()
xmin = numpy.amin(points[:, 0])
xmax = numpy.amax(points[:, 0])
ymin = numpy.amin(points[:, 1])
yma... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def put(self, job, result):
"Perform a job by a member in the pool and return the result."
self.job.put(job)
r = result.get()
return r |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def contract(self, jobs, result):
""" Perform a contract on a number of jobs and block until a result is retrieved for each job. """ |
for j in jobs:
WorkerPool.put(self, j)
r = []
for i in xrange(len(jobs)):
r.append(result.get())
return r |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def grow(self):
"Add another worker to the pool."
t = self.worker_factory(self)
t.start()
self._size += 1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def shrink(self):
"Get rid of one worker from the pool. Raises IndexError if empty."
if self._size <= 0:
raise IndexError("pool is already empty")
self._size -= 1
self.put(SuicideJob()) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def map(self, fn, *seq):
"Perform a map operation distributed among the workers. Will "
"block until done."
results = Queue()
args = zip(*seq)
for seq in args:
j = SimpleJob(results, fn, seq)
self.put(j)
# Aggregate results
r = []
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def run(self):
"Get jobs from the queue and perform them as they arrive."
while 1:
# Sleep until there is a job to perform.
job = self.jobs.get()
# Yawn. Time to get some work done.
try:
job.run()
self.jobs.task_done()
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def display(contents, domain=DEFAULT_DOMAIN, force_gist=False):
""" Open a web browser pointing to geojson.io with the specified content. If the content is large... |
url = make_url(contents, domain, force_gist)
webbrowser.open(url)
return url |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def make_url(contents, domain=DEFAULT_DOMAIN, force_gist=False, size_for_gist=MAX_URL_LEN):
""" Returns the URL to open given the domain and contents. If the fil... |
contents = make_geojson(contents)
if len(contents) <= size_for_gist and not force_gist:
url = data_url(contents, domain)
else:
gist = _make_gist(contents)
url = gist_url(gist.id, domain)
return url |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def make_geojson(contents):
""" Return a GeoJSON string from a variety of inputs. See the documentation for make_url for the possible contents input. Returns ---... |
if isinstance(contents, six.string_types):
return contents
if hasattr(contents, '__geo_interface__'):
features = [_geo_to_feature(contents)]
else:
try:
feature_iter = iter(contents)
except TypeError:
raise ValueError('Unknown type for input')
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data_url(contents, domain=DEFAULT_DOMAIN):
""" Return the URL for embedding the GeoJSON data in the URL hash Parameters contents - string of GeoJSON domain -... |
url = (domain + '#data=data:application/json,' +
urllib.parse.quote(contents))
return url |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _make_gist(contents, description='', filename='data.geojson'):
""" Create and return an anonymous gist with a single file and specified contents """ |
ghapi = github3.GitHub()
files = {filename: {'content': contents}}
gist = ghapi.create_gist(description, files)
return gist |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def clenshaw(a, alpha, beta, t):
"""Clenshaw's algorithm for evaluating S(t) = \\sum a_k P_k(alpha, beta)(t) where P_k(alpha, beta) is the kth orthogonal polynom... |
n = len(alpha)
assert len(beta) == n
assert len(a) == n + 1
try:
b = numpy.empty((n + 1,) + t.shape)
except AttributeError: # 'float' object has no attribute 'shape'
b = numpy.empty(n + 1)
# b[0] is unused, can be any value
# TODO shift the array
b[0] = 1.0
b[n] ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def recurrence_coefficients(n, alpha, standardization="normal", symbolic=False):
"""Recurrence coefficients for generalized Laguerre polynomials. vals_k = vals_{... |
S = sympy.S if symbolic else lambda x: x
sqrt = sympy.sqrt if symbolic else numpy.sqrt
gamma = sympy.gamma if symbolic else scipy.special.gamma
if standardization == "monic":
p0 = 1
a = n * [1]
b = [2 * k + 1 + alpha for k in range(n)]
c = [k * (k + alpha) for k in rang... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def plot(f, lcar=1.0e-1):
"""Plot function over a disk. """ |
import matplotlib
import matplotlib.pyplot as plt
import pygmsh
geom = pygmsh.built_in.Geometry()
geom.add_circle([0.0, 0.0, 0.0], 1.0, lcar, num_sections=4, compound=True)
points, cells, _, _, _ = pygmsh.generate_mesh(geom, verbose=True)
x = points[:, 0]
y = points[:, 1]
triang =... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def tree(X, n, symbolic=False):
"""Evaluates the entire tree of orthogonal polynomials for the n-cube The computation is organized such that tree returns a list ... |
p0, a, b, c = legendre(n + 1, "normal", symbolic=symbolic)
dim = X.shape[0]
p0n = p0 ** dim
out = []
level = numpy.array([numpy.ones(X.shape[1:], dtype=int) * p0n])
out.append(level)
# TODO use a simpler binom implementation
for L in range(n):
level = []
for i in ran... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def plot(corners, f, n=100):
"""Plot function over a triangle. """ |
import matplotlib.tri
import matplotlib.pyplot as plt
# discretization points
def partition(boxes, balls):
# <https://stackoverflow.com/a/36748940/353337>
def rec(boxes, balls, parent=tuple()):
if boxes > 1:
for i in range(balls + 1):
for... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _iget(key, lookup_dict):
""" Case-insensitive search for `key` within keys of `lookup_dict`. """ |
for k, v in lookup_dict.items():
if k.lower() == key.lower():
return v
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(filename, f):
"""Write a function `f` defined in terms of spherical coordinates to a file. """ |
import meshio
import meshzoo
points, cells = meshzoo.iso_sphere(5)
# get spherical coordinates from points
polar = numpy.arccos(points[:, 2])
azimuthal = numpy.arctan2(points[:, 1], points[:, 0])
vals = f(polar, azimuthal)
meshio.write(filename, points, {"triangle": cells}, point_data=... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def tree_sph(polar, azimuthal, n, standardization, symbolic=False):
"""Evaluate all spherical harmonics of degree at most `n` at angles `polar`, `azimuthal`. """ |
cos = numpy.vectorize(sympy.cos) if symbolic else numpy.cos
# Conventions from
# <https://en.wikipedia.org/wiki/Spherical_harmonics#Orthogonality_and_normalization>.
config = {
"acoustic": ("complex spherical", False),
"quantum mechanic": ("complex spherical", True),
"geodetic"... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_if_this_file_exist(filename):
"""Check if this file exist and if it's a directory This function will check if the given filename actually exists and if... |
#get the absolute path
filename = os.path.abspath(filename)
#Boolean
this_file_exist = os.path.exists(filename)
a_directory = os.path.isdir(filename)
result = this_file_exist and not a_directory
if result == False:
raise ValueError('The filename given was either non existent or wa... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def command_line(cmd):
"""Handle the command line call keyword arguments: cmd = a list return 0 if error or a string for the command line output """ |
try:
s = subprocess.Popen(cmd, stdout=subprocess.PIPE)
s = s.stdout.read()
return s.strip()
except subprocess.CalledProcessError:
return 0 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def information(filename):
"""Returns the file exif""" |
check_if_this_file_exist(filename)
filename = os.path.abspath(filename)
result = get_json(filename)
result = result[0]
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_json(filename):
""" Return a json value of the exif Get a filename and return a JSON object Arguments: filename {string} -- your filename Returns: [JSON]... |
check_if_this_file_exist(filename)
#Process this function
filename = os.path.abspath(filename)
s = command_line(['exiftool', '-G', '-j', '-sort', filename])
if s:
#convert bytes to string
s = s.decode('utf-8').rstrip('\r\n')
return json.loads(s)
else:
return s |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_csv(filename):
""" Return a csv representation of the exif get a filename and returns a unicode string with a CSV format Arguments: filename {string} -- ... |
check_if_this_file_exist(filename)
#Process this function
filename = os.path.abspath(filename)
s = command_line(['exiftool', '-G', '-csv', '-sort', filename])
if s:
#convert bytes to string
s = s.decode('utf-8')
return s
else:
return 0 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def render(self, context=None, clean=False):
""" Render email with provided context Arguments --------- context : dict |context| If not specified then the :attr:... |
# Load template if it is not loaded yet.
if not self.template:
self.load_template(self.template_name)
# The signature of the `render()` method was changed in Django 1.7.
# https://docs.djangoproject.com/en/1.8/ref/templates/upgrading/#get-template-and-select-template
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send(self, *args, **kwargs):
""" Send email message, render if it is not rendered yet. Note ---- Any extra arguments are passed to :class:`EmailMultiAlternat... |
clean = kwargs.pop('clean', False)
if not self._is_rendered:
self.render()
if clean:
self.clean()
return super(EmailMessage, self).send(*args, **kwargs) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send_mail(template_name, context, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, **kwargs):
""" Easy w... |
connection = connection or mail.get_connection(username=auth_user,
password=auth_password,
fail_silently=fail_silently)
clean = kwargs.pop('clean', True)
return EmailMessage(
template_name, contex... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def silhouette_score(X, labels, metric='euclidean', sample_size=None, random_state=None, **kwds):
"""Compute the mean Silhouette Coefficient of all samples. The ... |
if sample_size is not None:
X, labels = check_X_y(X, labels, accept_sparse=['csc', 'csr'])
random_state = check_random_state(random_state)
indices = random_state.permutation(X.shape[0])[:sample_size]
if metric == "precomputed":
X, labels = X[indices].T[indices].T, labels... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def silhouette_samples(X, labels, metric='euclidean', **kwds):
"""Compute the Silhouette Coefficient for each sample. The Silhouette Coefficient is a measure of ... |
X, labels = check_X_y(X, labels, accept_sparse=['csc', 'csr'])
le = LabelEncoder()
labels = le.fit_transform(labels)
check_number_of_labels(len(le.classes_), X.shape[0])
distances = pairwise_distances(X, metric=metric, **kwds)
unique_labels = le.classes_
n_samples_per_label = np.bincount(l... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def calinski_harabaz_score(X, labels):
"""Compute the Calinski and Harabaz score. The score is defined as ratio between the within-cluster dispersion and the bet... |
X, labels = check_X_y(X, labels)
le = LabelEncoder()
labels = le.fit_transform(labels)
n_samples, _ = X.shape
n_labels = len(le.classes_)
check_number_of_labels(n_labels, n_samples)
extra_disp, intra_disp = 0., 0.
mean = np.mean(X, axis=0)
for k in range(n_labels):
cluste... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def handle_zeros_in_scale(scale, copy=True):
''' Makes sure that whenever scale is zero, we handle it correctly.
This happens in most scalers when we have constant features.
Adapted from sklearn.preprocessing.data'''
# if we are fitting on 1D arrays, scale might be a scalar
if np.isscalar(scale):
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _joint_probabilities(distances, desired_perplexity, verbose):
"""Compute joint probabilities p_ij from distances. Parameters distances : array, shape (n_samp... |
# Compute conditional probabilities such that they approximately match
# the desired perplexity
distances = distances.astype(np.float32, copy=False)
conditional_P = _utils._binary_search_perplexity(
distances, None, desired_perplexity, verbose)
P = conditional_P + conditional_P.T
sum_P ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _joint_probabilities_nn(distances, neighbors, desired_perplexity, verbose):
"""Compute joint probabilities p_ij from distances using just nearest neighbors. ... |
t0 = time()
# Compute conditional probabilities such that they approximately match
# the desired perplexity
n_samples, k = neighbors.shape
distances = distances.astype(np.float32, copy=False)
neighbors = neighbors.astype(np.int64, copy=False)
conditional_P = _utils._binary_search_perplexity... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _gradient_descent(objective, p0, it, n_iter, n_iter_check=1, n_iter_without_progress=300, momentum=0.8, learning_rate=200.0, min_gain=0.01, min_grad_norm=1e-7... |
if args is None:
args = []
if kwargs is None:
kwargs = {}
p = p0.copy().ravel()
update = np.zeros_like(p)
gains = np.ones_like(p)
error = np.finfo(np.float).max
best_error = np.finfo(np.float).max
best_iter = i = it
tic = time()
for i in range(it, n_iter):
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def trustworthiness(X, X_embedded, n_neighbors=5, precomputed=False):
"""Expresses to what extent the local structure is retained. The trustworthiness is within ... |
if precomputed:
dist_X = X
else:
dist_X = pairwise_distances(X, squared=True)
dist_X_embedded = pairwise_distances(X_embedded, squared=True)
ind_X = np.argsort(dist_X, axis=1)
ind_X_embedded = np.argsort(dist_X_embedded, axis=1)[:, 1:n_neighbors + 1]
n_samples = X.shape[0]
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.