sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def arc(pRA, pDecl, sRA, sDecl, mcRA, lat):
""" Returns the arc of direction between a Promissor
and Significator. It uses the generic proportional
semi-arc method.
"""
pDArc, pNArc = utils.dnarcs(pDecl, lat)
sDArc, sNArc = utils.dnarcs(sDecl, lat)
# Select meridian and arcs to b... | Returns the arc of direction between a Promissor
and Significator. It uses the generic proportional
semi-arc method. | entailment |
def getArc(prom, sig, mc, pos, zerolat):
""" Returns the arc of direction between a promissor
and a significator. Arguments are also the MC, the
geoposition and zerolat to assume zero ecliptical
latitudes.
ZeroLat true => inZodiaco, false => inMundo
"""
pRA, pDecl = prom.eqCoords(... | Returns the arc of direction between a promissor
and a significator. Arguments are also the MC, the
geoposition and zerolat to assume zero ecliptical
latitudes.
ZeroLat true => inZodiaco, false => inMundo | entailment |
def _buildTerms(self):
""" Builds a data structure indexing the terms
longitude by sign and object.
"""
termLons = tables.termLons(tables.EGYPTIAN_TERMS)
res = {}
for (ID, sign, lon) in termLons:
try:
res[sign][ID] = lon
ex... | Builds a data structure indexing the terms
longitude by sign and object. | entailment |
def G(self, ID, lat, lon):
""" Creates a generic entry for an object. """
# Equatorial coordinates
eqM = utils.eqCoords(lon, lat)
eqZ = eqM
if lat != 0:
eqZ = utils.eqCoords(lon, 0)
return {
'id': ID,
'lat': lat,
... | Creates a generic entry for an object. | entailment |
def T(self, ID, sign):
""" Returns the term of an object in a sign. """
lon = self.terms[sign][ID]
ID = 'T_%s_%s' % (ID, sign)
return self.G(ID, 0, lon) | Returns the term of an object in a sign. | entailment |
def A(self, ID):
""" Returns the Antiscia of an object. """
obj = self.chart.getObject(ID).antiscia()
ID = 'A_%s' % (ID)
return self.G(ID, obj.lat, obj.lon) | Returns the Antiscia of an object. | entailment |
def C(self, ID):
""" Returns the CAntiscia of an object. """
obj = self.chart.getObject(ID).cantiscia()
ID = 'C_%s' % (ID)
return self.G(ID, obj.lat, obj.lon) | Returns the CAntiscia of an object. | entailment |
def D(self, ID, asp):
""" Returns the dexter aspect of an object. """
obj = self.chart.getObject(ID).copy()
obj.relocate(obj.lon - asp)
ID = 'D_%s_%s' % (ID, asp)
return self.G(ID, obj.lat, obj.lon) | Returns the dexter aspect of an object. | entailment |
def N(self, ID, asp=0):
""" Returns the conjunction or opposition aspect
of an object.
"""
obj = self.chart.get(ID).copy()
obj.relocate(obj.lon + asp)
ID = 'N_%s_%s' % (ID, asp)
return self.G(ID, obj.lat, obj.lon) | Returns the conjunction or opposition aspect
of an object. | entailment |
def _arc(self, prom, sig):
""" Computes the in-zodiaco and in-mundo arcs
between a promissor and a significator.
"""
arcm = arc(prom['ra'], prom['decl'],
sig['ra'], sig['decl'],
self.mcRA, self.lat)
arcz = arc(prom['raZ'], prom['d... | Computes the in-zodiaco and in-mundo arcs
between a promissor and a significator. | entailment |
def getArc(self, prom, sig):
""" Returns the arcs between a promissor and
a significator. Should uses the object creation
functions to build the objects.
"""
res = self._arc(prom, sig)
res.update({
'prom': prom['id'],
'sig': sig['id']
... | Returns the arcs between a promissor and
a significator. Should uses the object creation
functions to build the objects. | entailment |
def _elements(self, IDs, func, aspList):
""" Returns the IDs as objects considering the
aspList and the function.
"""
res = []
for asp in aspList:
if (asp in [0, 180]):
# Generate func for conjunctions and oppositions
if func =... | Returns the IDs as objects considering the
aspList and the function. | entailment |
def _terms(self):
""" Returns a list with the objects as terms. """
res = []
for sign, terms in self.terms.items():
for ID, lon in terms.items():
res.append(self.T(ID, sign))
return res | Returns a list with the objects as terms. | entailment |
def getList(self, aspList):
""" Returns a sorted list with all
primary directions.
"""
# Significators
objects = self._elements(self.SIG_OBJECTS, self.N, [0])
houses = self._elements(self.SIG_HOUSES, self.N, [0])
angles = self._elements(self.SIG_ANGLES, ... | Returns a sorted list with all
primary directions. | entailment |
def view(self, arcmin, arcmax):
""" Returns the directions within the
min and max arcs.
"""
res = []
for direction in self.table:
if arcmin < direction[0] < arcmax:
res.append(direction)
return res | Returns the directions within the
min and max arcs. | entailment |
def bySignificator(self, ID):
""" Returns all directions to a significator. """
res = []
for direction in self.table:
if ID in direction[2]:
res.append(direction)
return res | Returns all directions to a significator. | entailment |
def byPromissor(self, ID):
""" Returns all directions to a promissor. """
res = []
for direction in self.table:
if ID in direction[1]:
res.append(direction)
return res | Returns all directions to a promissor. | entailment |
def copy(self):
""" Returns a deep copy of this chart. """
chart = Chart.__new__(Chart)
chart.date = self.date
chart.pos = self.pos
chart.hsys = self.hsys
chart.objects = self.objects.copy()
chart.houses = self.houses.copy()
chart.angles = self.angles.copy... | Returns a deep copy of this chart. | entailment |
def get(self, ID):
""" Returns an object, house or angle
from the chart.
"""
if ID.startswith('House'):
return self.getHouse(ID)
elif ID in const.LIST_ANGLES:
return self.getAngle(ID)
else:
return self.getObject(ID) | Returns an object, house or angle
from the chart. | entailment |
def getFixedStars(self):
""" Returns a list with all fixed stars. """
IDs = const.LIST_FIXED_STARS
return ephem.getFixedStarList(IDs, self.date) | Returns a list with all fixed stars. | entailment |
def isHouse1Asc(self):
""" Returns true if House1 is the same as the Asc. """
house1 = self.getHouse(const.HOUSE1)
asc = self.getAngle(const.ASC)
dist = angle.closestdistance(house1.lon, asc.lon)
return abs(dist) < 0.0003 | Returns true if House1 is the same as the Asc. | entailment |
def isHouse10MC(self):
""" Returns true if House10 is the same as the MC. """
house10 = self.getHouse(const.HOUSE10)
mc = self.getAngle(const.MC)
dist = angle.closestdistance(house10.lon, mc.lon)
return abs(dist) < 0.0003 | Returns true if House10 is the same as the MC. | entailment |
def isDiurnal(self):
""" Returns true if this chart is diurnal. """
sun = self.getObject(const.SUN)
mc = self.getAngle(const.MC)
# Get ecliptical positions and check if the
# sun is above the horizon.
lat = self.pos.lat
sunRA, sunDecl = utils.eqCoords(sun... | Returns true if this chart is diurnal. | entailment |
def getMoonPhase(self):
""" Returns the phase of the moon. """
sun = self.getObject(const.SUN)
moon = self.getObject(const.MOON)
dist = angle.distance(sun.lon, moon.lon)
if dist < 90:
return const.MOON_FIRST_QUARTER
elif dist < 180:
return const.MO... | Returns the phase of the moon. | entailment |
def solarReturn(self, year):
""" Returns this chart's solar return for a
given year.
"""
sun = self.getObject(const.SUN)
date = Datetime('{0}/01/01'.format(year),
'00:00',
self.date.utcoffset)
srDate = ephem.nextS... | Returns this chart's solar return for a
given year. | entailment |
def objLon(ID, chart):
""" Returns the longitude of an object. """
if ID.startswith('$R'):
# Return Ruler
ID = ID[2:]
obj = chart.get(ID)
rulerID = essential.ruler(obj.sign)
ruler = chart.getObject(rulerID)
return ruler.lon
elif ID.startswith('Pars'):
... | Returns the longitude of an object. | entailment |
def partLon(ID, chart):
""" Returns the longitude of an arabic part. """
# Get diurnal or nocturnal formula
abc = FORMULAS[ID][0] if chart.isDiurnal() else FORMULAS[ID][1]
a = objLon(abc[0], chart)
b = objLon(abc[1], chart)
c = objLon(abc[2], chart)
return c + b - a | Returns the longitude of an arabic part. | entailment |
def getPart(ID, chart):
""" Returns an Arabic Part. """
obj = GenericObject()
obj.id = ID
obj.type = const.OBJ_ARABIC_PART
obj.relocate(partLon(ID, chart))
return obj | Returns an Arabic Part. | entailment |
def sweObject(obj, jd):
""" Returns an object from the Ephemeris. """
sweObj = SWE_OBJECTS[obj]
sweList = swisseph.calc_ut(jd, sweObj)
return {
'id': obj,
'lon': sweList[0],
'lat': sweList[1],
'lonspeed': sweList[3],
'latspeed': sweList[4]
} | Returns an object from the Ephemeris. | entailment |
def sweObjectLon(obj, jd):
""" Returns the longitude of an object. """
sweObj = SWE_OBJECTS[obj]
sweList = swisseph.calc_ut(jd, sweObj)
return sweList[0] | Returns the longitude of an object. | entailment |
def sweNextTransit(obj, jd, lat, lon, flag):
""" Returns the julian date of the next transit of
an object. The flag should be 'RISE' or 'SET'.
"""
sweObj = SWE_OBJECTS[obj]
flag = swisseph.CALC_RISE if flag == 'RISE' else swisseph.CALC_SET
trans = swisseph.rise_trans(jd, sweObj, lon, lat, ... | Returns the julian date of the next transit of
an object. The flag should be 'RISE' or 'SET'. | entailment |
def sweHouses(jd, lat, lon, hsys):
""" Returns lists of houses and angles. """
hsys = SWE_HOUSESYS[hsys]
hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
# Add first house to the end of 'hlist' so that we
# can compute house sizes with an iterator
hlist += (hlist[0],)
houses = [
{... | Returns lists of houses and angles. | entailment |
def sweHousesLon(jd, lat, lon, hsys):
""" Returns lists with house and angle longitudes. """
hsys = SWE_HOUSESYS[hsys]
hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
angles = [
ascmc[0],
ascmc[1],
angle.norm(ascmc[0] + 180),
angle.norm(ascmc[1] + 180)
]
retur... | Returns lists with house and angle longitudes. | entailment |
def sweFixedStar(star, jd):
""" Returns a fixed star from the Ephemeris. """
sweList = swisseph.fixstar_ut(star, jd)
mag = swisseph.fixstar_mag(star)
return {
'id': star,
'mag': mag,
'lon': sweList[0],
'lat': sweList[1]
} | Returns a fixed star from the Ephemeris. | entailment |
def solarEclipseGlobal(jd, backward):
""" Returns the jd details of previous or next global solar eclipse. """
sweList = swisseph.sol_eclipse_when_glob(jd, backward=backward)
return {
'maximum': sweList[1][0],
'begin': sweList[1][2],
'end': sweList[1][3],
'totality_begin': s... | Returns the jd details of previous or next global solar eclipse. | entailment |
def lunarEclipseGlobal(jd, backward):
""" Returns the jd details of previous or next global lunar eclipse. """
sweList = swisseph.lun_eclipse_when(jd, backward=backward)
return {
'maximum': sweList[1][0],
'partial_begin': sweList[1][2],
'partial_end': sweList[1][3],
'totalit... | Returns the jd details of previous or next global lunar eclipse. | entailment |
def dateJDN(year, month, day, calendar):
""" Converts date to Julian Day Number. """
a = (14 - month) // 12
y = year + 4800 - a
m = month + 12*a - 3
if calendar == GREGORIAN:
return day + (153*m + 2)//5 + 365*y + y//4 - y//100 + y//400 - 32045
else:
return day + (153*m + 2)//5 + ... | Converts date to Julian Day Number. | entailment |
def jdnDate(jdn):
""" Converts Julian Day Number to Gregorian date. """
a = jdn + 32044
b = (4*a + 3) // 146097
c = a - (146097*b) // 4
d = (4*c + 3) // 1461
e = c - (1461*d) // 4
m = (5*e + 2) // 153
day = e + 1 - (153*m + 2) // 5
month = m + 3 - 12*(m//10)
year = 100*b + d - 48... | Converts Julian Day Number to Gregorian date. | entailment |
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 | Returns date as signed list. | entailment |
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 | Returns date as string. | entailment |
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) | Returns a new Time object set to UTC given
an offset Time object. | entailment |
def time(self):
""" Returns time as list [hh,mm,ss]. """
slist = self.toList()
if slist[0] == '-':
slist[1] *= -1
# We must do a trick if we want to
# make negative zeros explicit
if slist[1] == -0:
slist[1] = -0.0
return s... | Returns time as list [hh,mm,ss]. | entailment |
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 | Returns time as signed list. | entailment |
def toString(self):
""" Returns time as string. """
slist = self.toList()
string = angle.slistStr(slist)
return string if slist[0] == '-' else string[1:] | Returns time as string. | entailment |
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)
... | Builds a Datetime object given a jd and utc offset. | entailment |
def getUTC(self):
""" Returns this Datetime localized for UTC. """
timeUTC = self.time.getUTC(self.utcoffset)
dateUTC = Date(round(self.jd))
return Datetime(dateUTC, timeUTC) | Returns this Datetime localized for UTC. | entailment |
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 ... | Returns an object for a specific date and
location. | entailment |
def getHouses(jd, lat, lon, hsys):
""" Returns lists of houses and angles. """
houses, angles = swe.sweHouses(jd, lat, lon, hsys)
for house in houses:
_signInfo(house)
for angle in angles:
_signInfo(angle)
return (houses, angles) | Returns lists of houses and angles. | entailment |
def getFixedStar(ID, jd):
""" Returns a fixed star. """
star = swe.sweFixedStar(ID, jd)
_signInfo(star)
return star | Returns a fixed star. | entailment |
def nextSunrise(jd, lat, lon):
""" Returns the JD of the next sunrise. """
return swe.sweNextTransit(const.SUN, jd, lat, lon, 'RISE') | Returns the JD of the next sunrise. | entailment |
def nextSunset(jd, lat, lon):
""" Returns the JD of the next sunset. """
return swe.sweNextTransit(const.SUN, jd, lat, lon, 'SET') | Returns the JD of the next sunset. | entailment |
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
}) | Appends the sign id and longitude to an object. | entailment |
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)[... | Returns the ecliptic longitude of Pars Fortuna.
It considers diurnal or nocturnal conditions. | entailment |
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'])
... | Returns true if the sun is above the horizon
of a given date and location. | entailment |
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... | Finds the latest new or full moon and
returns the julian date of that event. | entailment |
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.distan... | Finds the julian date before or after
'jd' when the sun is at longitude 'lon'.
It searches forward by default. | entailment |
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:
r... | Finds the aproximate julian date of the
next station of a planet. | entailment |
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... | Removes all python cache files recursively on a path.
:param path: the path
:return: None | entailment |
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)) | Removes all .py files.
:param path: the path
:return: None | entailment |
def toFloat(value):
""" Converts angle representation to float.
Accepts angles and strings such as "12W30:00".
"""
if isinstance(value, str):
# Find lat/lon char in string and insert angle sign
value = value.upper()
for char in ['N', 'S', 'E', 'W']:
if char in v... | Converts angle representation to float.
Accepts angles and strings such as "12W30:00". | entailment |
def toString(value, mode):
""" Converts angle float to string.
Mode refers to LAT/LON.
"""
string = angle.toString(value)
sign = string[0]
separator = CHAR[mode][sign]
string = string.replace(':', separator, 1)
return string[1:] | Converts angle float to string.
Mode refers to LAT/LON. | entailment |
def strings(self):
""" Return lat/lon as strings. """
return [
toString(self.lat, LAT),
toString(self.lon, LON)
] | Return lat/lon as strings. | entailment |
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(a... | Returns a list with the orb and angular
distances from obj1 to obj2, considering a
list of possible aspects. | entailment |
def _aspectDict(obj1, obj2, aspList):
""" Returns the properties of the aspect of
obj1 to obj2, considering a list of possible
aspects.
This function makes the following assumptions:
- Syzygy does not start aspects but receives
any aspect.
- Pars Fortuna and Moon Nodes only starts
... | Returns the properties of the aspect of
obj1 to obj2, considering a list of possible
aspects.
This function makes the following assumptions:
- Syzygy does not start aspects but receives
any aspect.
- Pars Fortuna and Moon Nodes only starts
conjunctions but receive any aspect.
... | entailment |
def _aspectProperties(obj1, obj2, aspDict):
""" Returns the properties of an aspect between
obj1 and obj2, given by 'aspDict'.
This function assumes obj1 to be the active object,
i.e., the one responsible for starting the aspect.
"""
orb = aspDict['orb']
asp = aspDict['type']
... | Returns the properties of an aspect between
obj1 and obj2, given by 'aspDict'.
This function assumes obj1 to be the active object,
i.e., the one responsible for starting the aspect. | entailment |
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
... | Returns which is the active and the passive objects. | entailment |
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 | Returns the aspect type between objects considering
a list of possible aspect types. | entailment |
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 | Returns if there is an aspect between objects
considering a list of possible aspect types. | entailment |
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 | Returns if obj1 aspects obj2 within its orb,
considering a list of possible aspect types. | entailment |
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 = {
... | Returns an Aspect object for the aspect between two
objects considering a list of possible aspect types. | entailment |
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 than 1
degree.
"""
mov = self.active.movement
if self.orb < 1 and mov == const.SEPARATIVE:
... | Returns the movement of this aspect.
The movement is the one of the active object, except
if the active is separating but within less than 1
degree. | entailment |
def getRole(self, ID):
""" Returns the role (active or passive) of an object
in this aspect.
"""
if self.active.id == ID:
return {
'role': 'active',
'inOrb': self.active.inOrb,
'movement': self.active.movement
... | Returns the role (active or passive) of an object
in this aspect. | entailment |
def setFaces(variant):
"""
Sets the default faces variant
"""
global FACES
if variant == CHALDEAN_FACES:
FACES = tables.CHALDEAN_FACES
else:
FACES = tables.TRIPLICITY_FACES | Sets the default faces variant | entailment |
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.... | Sets the default terms of the Dignities
table. | entailment |
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 | Returns the term for a sign and longitude. | entailment |
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] | Returns the face for a sign and longitude. | entailment |
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, ... | Returns the complete essential dignities
for a sign and longitude. | entailment |
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 | Returns if an object is peregrine
on a sign and longitude. | entailment |
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]) | Returns the score of an object on
a sign and longitude. | entailment |
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] | Returns the almutem for a given
sign and longitude. | entailment |
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 | Returns the dignities belonging to this object. | entailment |
def isPeregrine(self):
""" Returns if this object is peregrine. """
return isPeregrine(self.obj.id,
self.obj.sign,
self.obj.signlon) | Returns if this object is peregrine. | entailment |
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) | Internal function to return a new chart for
a specific date using properties from old chart. | entailment |
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) | Returns the solar return of a Chart
after a specific date. | entailment |
def hourTable(date, pos):
""" Creates the planetary hour table for a date
and position.
The table includes both diurnal and nocturnal
hour sequences and each of the 24 entries (12 * 2)
are like (startJD, endJD, ruler).
"""
lastSunrise = ephem.lastSunrise(date, pos)
midd... | Creates the planetary hour table for a date
and position.
The table includes both diurnal and nocturnal
hour sequences and each of the 24 entries (12 * 2)
are like (startJD, endJD, ruler). | entailment |
def getHourTable(date, pos):
""" Returns an HourTable object. """
table = hourTable(date, pos)
return HourTable(table, date) | Returns an HourTable object. | entailment |
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 | Returns the index of a date in the table. | entailment |
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(),
... | Returns information about a specific
planetary time. | entailment |
def compute(chart, date, fixedObjects=False):
""" Returns a profection chart for a given
date. Receives argument 'fixedObjects' to
fix chart objects in their natal locations.
"""
sun = chart.getObject(const.SUN)
prevSr = ephem.prevSolarReturn(date, sun.lon)
nextSr = ephem.nextSolar... | Returns a profection chart for a given
date. Receives argument 'fixedObjects' to
fix chart objects in their natal locations. | entailment |
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_) | Merges two list of objects removing
repetitions. | entailment |
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, ... | Computes the behavior. | entailment |
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)
... | Returns a list with the absolute longitude
of all terms. | entailment |
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)
]
... | Computes the Almutem table. | entailment |
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 - gophish.models.Model - The resource class
resource_id - str - The end... | Gets the details for one or more resources by ID
Args:
cls - gophish.models.Model - The resource class
resource_id - str - The endpoint (URL path) for the resource
resource_action - str - An action to perform on the resource
resource_cls - cls - A class to use fo... | entailment |
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 ... | Creates a new instance of the resource.
Args:
resource - gophish.models.Model - The resource instance | entailment |
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("PU... | Edits an existing resource
Args:
resource - gophish.models.Model - The resource instance | entailment |
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:
... | Deletes an existing resource
Args:
resource_id - int - The resource ID to be deleted | entailment |
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... | Returns a dict representation of the resource | entailment |
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":... | Executes a request to a given endpoint, returning the result | entailment |
def complete(self, campaign_id):
""" Complete an existing campaign (Stop processing events) """
return super(API, self).get(
resource_id=campaign_id, resource_action='complete') | Complete an existing campaign (Stop processing events) | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.