text stringlengths 81 112k |
|---|
Has similar inputs and return value to to :func:`_load_point`, except is
for handling MULTILINESTRING geometry.
:returns:
A GeoJSON `dict` MultiLineString representation of the WKT ``string``.
def _load_multilinestring(tokens, string):
"""
Has similar inputs and return value to to :func:`_load... |
Has similar inputs and return value to to :func:`_load_point`, except is
for handling GEOMETRYCOLLECTIONs.
Delegates parsing to the parsers for the individual geometry types.
:returns:
A GeoJSON `dict` GeometryCollection representation of the WKT
``string``.
def _load_geometrycollection(t... |
Merge shared params and new params.
def _get_request_params(self, **kwargs):
"""Merge shared params and new params."""
request_params = copy.deepcopy(self._shared_request_params)
for key, value in iteritems(kwargs):
if isinstance(value, dict) and key in request_params:
... |
Remove keyword arguments not used by `requests`
def _sanitize_request_params(self, request_params):
"""Remove keyword arguments not used by `requests`"""
if 'verify_ssl' in request_params:
request_params['verify'] = request_params.pop('verify_ssl')
return dict((key, val) for key, va... |
Send a :class:`requests.Request` and demand a
:class:`requests.Response`
def request(self, method, path, **kwargs):
"""Send a :class:`requests.Request` and demand a
:class:`requests.Response`
"""
if path:
url = '%s/%s' % (self.url.rstrip('/'), path.lstrip('/'))
... |
Override this method to modify sent request parameters
def pre_send(self, request_params):
"""Override this method to modify sent request parameters"""
for adapter in itervalues(self.adapters):
adapter.max_retries = request_params.get('max_retries', 0)
return request_params |
Override this method to create a different definition of
what kind of response is acceptable.
If `bool(the_return_value) is False` then an `HTTPServiceError`
will be raised.
For example, you might want to assert that the body must be empty,
so you could return `len(response.cont... |
Rounds a signed list over the last element and removes it.
def _roundSlist(slist):
""" Rounds a signed list over the last element and removes it. """
slist[-1] = 60 if slist[-1] >= 30 else 0
for i in range(len(slist)-1, 1, -1):
if slist[i] == 60:
slist[i] = 0
slist[i-1] += 1... |
Converts angle string to signed list.
def strSlist(string):
""" Converts angle string to signed list. """
sign = '-' if string[0] == '-' else '+'
values = [abs(int(x)) for x in string.split(':')]
return _fixSlist(list(sign) + values) |
Converts signed list to angle string.
def slistStr(slist):
""" Converts signed list to angle string. """
slist = _fixSlist(slist)
string = ':'.join(['%02d' % x for x in slist[1:]])
return slist[0] + string |
Converts signed list to float.
def slistFloat(slist):
""" Converts signed list to float. """
values = [v / 60**(i) for (i,v) in enumerate(slist[1:])]
value = sum(values)
return -value if slist[0] == '-' else value |
Converts float to signed list.
def floatSlist(value):
""" Converts float to signed list. """
slist = ['+', 0, 0, 0, 0]
if value < 0:
slist[0] = '-'
value = abs(value)
for i in range(1,5):
slist[i] = math.floor(value)
value = (value - slist[i]) * 60
return _roundSlist(sli... |
Converts string or signed list to float.
def toFloat(value):
""" Converts string or signed list to float. """
if isinstance(value, str):
return strFloat(value)
elif isinstance(value, list):
return slistFloat(value)
else:
return value |
Returns the dignities of A which belong to B.
def inDignities(self, idA, idB):
""" Returns the dignities of A which belong to B. """
objA = self.chart.get(idA)
info = essential.getInfo(objA.sign, objA.signlon)
# Should we ignore exile and fall?
return [dign for (dign, ID) in inf... |
Returns the dignities where A receives B.
A receives B when (1) B aspects A and (2) B is in
dignities of A.
def receives(self, idA, idB):
""" Returns the dignities where A receives B.
A receives B when (1) B aspects A and (2) B is in
dignities of A.
"""
objA =... |
Returns all pairs of dignities in mutual reception.
def mutualReceptions(self, idA, idB):
""" Returns all pairs of dignities in mutual reception. """
AB = self.receives(idA, idB)
BA = self.receives(idB, idA)
# Returns a product of both lists
return [(a,b) for a in AB for b in BA... |
Returns ruler and exaltation mutual receptions.
def reMutualReceptions(self, idA, idB):
""" Returns ruler and exaltation mutual receptions. """
mr = self.mutualReceptions(idA, idB)
filter_ = ['ruler', 'exalt']
# Each pair of dignities must be 'ruler' or 'exalt'
return [(a,b) for... |
Returns a list with the aspects an object
makes with the other six planets, considering a
list of possible aspects.
def validAspects(self, ID, aspList):
""" Returns a list with the aspects an object
makes with the other six planets, considering a
list of possible aspects.
... |
Returns the aspects an object makes with the
other six planets, separated by category (applicative,
separative, exact).
Aspects must be within orb of the object.
def aspectsByCat(self, ID, aspList):
""" Returns the aspects an object makes with the
other six planets, separated b... |
Returns the last separation and next application
considering a list of possible aspects.
def immediateAspects(self, ID, aspList):
""" Returns the last separation and next application
considering a list of possible aspects.
"""
asps = self.aspectsByCat(ID, aspList)
appl... |
Returns if a planet is Void of Course.
A planet is not VOC if has any exact or applicative aspects
ignoring the sign status (associate or dissociate).
def isVOC(self, ID):
""" Returns if a planet is Void of Course.
A planet is not VOC if has any exact or applicative aspects
igno... |
Single factor for the table.
def singleFactor(factors, chart, factor, obj, aspect=None):
"""" Single factor for the table. """
objID = obj if type(obj) == str else obj.id
res = {
'factor': factor,
'objID': objID,
'aspect': aspect
}
# For signs (obj as string) retur... |
Computes a factor for a modifier.
def modifierFactor(chart, factor, factorObj, otherObj, aspList):
""" Computes a factor for a modifier. """
asp = aspects.aspectType(factorObj, otherObj, aspList)
if asp != const.NO_ASPECT:
return {
'factor': factor,
'aspect': asp,
... |
Returns the factors for the temperament.
def getFactors(chart):
""" Returns the factors for the temperament. """
factors = []
# Asc sign
asc = chart.getAngle(const.ASC)
singleFactor(factors, chart, ASC_SIGN, asc.sign)
# Asc ruler
ascRulerID = essential.ruler(asc.sign)
asc... |
Returns the factors of the temperament modifiers.
def getModifiers(chart):
""" Returns the factors of the temperament modifiers. """
modifiers = []
# Factors which can be affected
asc = chart.getAngle(const.ASC)
ascRulerID = essential.ruler(asc.sign)
ascRuler = chart.getObject(ascRule... |
Computes the score of temperaments
and elements.
def scores(factors):
""" Computes the score of temperaments
and elements.
"""
temperaments = {
const.CHOLERIC: 0,
const.MELANCHOLIC: 0,
const.SANGUINE: 0,
const.PHLEGMATIC: 0
}
qualiti... |
Returns an ephemeris object.
def getObject(ID, date, pos):
""" Returns an ephemeris object. """
obj = eph.getObject(ID, date.jd, pos.lat, pos.lon)
return Object.fromDict(obj) |
Returns a list of objects.
def getObjectList(IDs, date, pos):
""" Returns a list of objects. """
objList = [getObject(ID, date, pos) for ID in IDs]
return ObjectList(objList) |
Returns the lists of houses and angles.
Since houses and angles are computed at the
same time, this function should be fast.
def getHouses(date, pos, hsys):
""" Returns the lists of houses and angles.
Since houses and angles are computed at the
same time, this function should be fast.
... |
Returns a fixed star from the ephemeris.
def getFixedStar(ID, date):
""" Returns a fixed star from the ephemeris. """
star = eph.getFixedStar(ID, date.jd)
return FixedStar.fromDict(star) |
Returns a list of fixed stars.
def getFixedStarList(IDs, date):
""" Returns a list of fixed stars. """
starList = [getFixedStar(ID, date) for ID in IDs]
return FixedStarList(starList) |
Returns the next date when sun is at longitude 'lon'.
def nextSolarReturn(date, lon):
""" Returns the next date when sun is at longitude 'lon'. """
jd = eph.nextSolarReturn(date.jd, lon)
return Datetime.fromJD(jd, date.utcoffset) |
Returns the previous date when sun is at longitude 'lon'.
def prevSolarReturn(date, lon):
""" Returns the previous date when sun is at longitude 'lon'. """
jd = eph.prevSolarReturn(date.jd, lon)
return Datetime.fromJD(jd, date.utcoffset) |
Returns the date of the next sunrise.
def nextSunrise(date, pos):
""" Returns the date of the next sunrise. """
jd = eph.nextSunrise(date.jd, pos.lat, pos.lon)
return Datetime.fromJD(jd, date.utcoffset) |
Returns the aproximate date of the next station.
def nextStation(ID, date):
""" Returns the aproximate date of the next station. """
jd = eph.nextStation(ID, date.jd)
return Datetime.fromJD(jd, date.utcoffset) |
Returns the Datetime of the maximum phase of the
previous global solar eclipse.
def prevSolarEclipse(date):
""" Returns the Datetime of the maximum phase of the
previous global solar eclipse.
"""
eclipse = swe.solarEclipseGlobal(date.jd, backward=True)
return Datetime.fromJD(eclipse['maximum'... |
Returns the Datetime of the maximum phase of the
next global solar eclipse.
def nextSolarEclipse(date):
""" Returns the Datetime of the maximum phase of the
next global solar eclipse.
"""
eclipse = swe.solarEclipseGlobal(date.jd, backward=False)
return Datetime.fromJD(eclipse['maximum'], date... |
Returns the Datetime of the maximum phase of the
previous global lunar eclipse.
def prevLunarEclipse(date):
""" Returns the Datetime of the maximum phase of the
previous global lunar eclipse.
"""
eclipse = swe.lunarEclipseGlobal(date.jd, backward=True)
return Datetime.fromJD(eclipse['maximum'... |
Returns the Datetime of the maximum phase of the
next global lunar eclipse.
def nextLunarEclipse(date):
""" Returns the Datetime of the maximum phase of the
next global lunar eclipse.
"""
eclipse = swe.lunarEclipseGlobal(date.jd, backward=False)
return Datetime.fromJD(eclipse['maximum'], date... |
Plots the tropical solar length
by year.
def plot(hdiff, title):
""" Plots the tropical solar length
by year.
"""
import matplotlib.pyplot as plt
years = [elem[0] for elem in hdiff]
diffs = [elem[1] for elem in hdiff]
plt.plot(years, diffs)
plt.ylabel('Distance in minutes')
... |
Returns the Ascensional Difference of a point.
def ascdiff(decl, lat):
""" Returns the Ascensional Difference of a point. """
delta = math.radians(decl)
phi = math.radians(lat)
ad = math.asin(math.tan(delta) * math.tan(phi))
return math.degrees(ad) |
Returns the diurnal and nocturnal arcs of a point.
def dnarcs(decl, lat):
""" Returns the diurnal and nocturnal arcs of a point. """
dArc = 180 + 2 * ascdiff(decl, lat)
nArc = 360 - dArc
return (dArc, nArc) |
Returns if an object's 'ra' and 'decl'
is above the horizon at a specific latitude,
given the MC's right ascension.
def isAboveHorizon(ra, decl, mcRA, lat):
""" Returns if an object's 'ra' and 'decl'
is above the horizon at a specific latitude,
given the MC's right ascension.
"""
#... |
Converts from ecliptical to equatorial coordinates.
This algorithm is described in book 'Primary Directions',
pp. 147-150.
def eqCoords(lon, lat):
""" Converts from ecliptical to equatorial coordinates.
This algorithm is described in book 'Primary Directions',
pp. 147-150.
"""
# Co... |
Returns an object's relation with the sun.
def sunRelation(obj, sun):
""" Returns an object's relation with the sun. """
if obj.id == const.SUN:
return None
dist = abs(angle.closestdistance(sun.lon, obj.lon))
if dist < 0.2833: return CAZIMI
elif dist < 8.0: return COMBUST
elif dist < 16... |
Returns if an object is augmenting or diminishing light.
def light(obj, sun):
""" Returns if an object is augmenting or diminishing light. """
dist = angle.distance(sun.lon, obj.lon)
faster = sun if sun.lonspeed > obj.lonspeed else obj
if faster == sun:
return LIGHT_DIMINISHING if dist < 180 el... |
Returns if an object is oriental or
occidental to the sun.
def orientality(obj, sun):
""" Returns if an object is oriental or
occidental to the sun.
"""
dist = angle.distance(sun.lon, obj.lon)
return OCCIDENTAL if dist < 180 else ORIENTAL |
Returns if an object is in Haiz.
def haiz(obj, chart):
""" Returns if an object is in Haiz. """
objGender = obj.gender()
objFaction = obj.faction()
if obj.id == const.MERCURY:
# Gender and faction of mercury depends on orientality
sun = chart.getObject(const.SUN)
orientalit... |
Returns the object's house.
def house(self):
""" Returns the object's house. """
house = self.chart.houses.getObjectHouse(self.obj)
return house |
Returns the relation of the object with the sun.
def sunRelation(self):
""" Returns the relation of the object with the sun. """
sun = self.chart.getObject(const.SUN)
return sunRelation(self.obj, sun) |
Returns if object is augmenting or diminishing its
light.
def light(self):
""" Returns if object is augmenting or diminishing its
light.
"""
sun = self.chart.getObject(const.SUN)
return light(self.obj, sun) |
Returns the orientality of the object.
def orientality(self):
""" Returns the orientality of the object. """
sun = self.chart.getObject(const.SUN)
return orientality(self.obj, sun) |
Returns if the object is in its house of joy.
def inHouseJoy(self):
""" Returns if the object is in its house of joy. """
house = self.house()
return props.object.houseJoy[self.obj.id] == house.id |
Returns if the object is in its sign of joy.
def inSignJoy(self):
""" Returns if the object is in its sign of joy. """
return props.object.signJoy[self.obj.id] == self.obj.sign |
Returns all mutual receptions with the object
and other planets, indexed by planet ID.
It only includes ruler and exaltation receptions.
def reMutualReceptions(self):
""" Returns all mutual receptions with the object
and other planets, indexed by planet ID.
It only includes ru... |
Returns a list with mutual receptions with the
object and other planets, when the reception is the
same for both (both ruler or both exaltation).
It basically return a list with every ruler-ruler and
exalt-exalt mutual receptions
def eqMutualReceptions(self):
""" Ret... |
Returns a list with the aspects that the object
makes to the objects in IDs. It considers only
conjunctions and other exact/applicative aspects
if in aspList.
def __aspectLists(self, IDs, aspList):
""" Returns a list with the aspects that the object
makes to the objects in IDs. ... |
Returns a list with the good aspects the object
makes to the benefics.
def aspectBenefics(self):
""" Returns a list with the good aspects the object
makes to the benefics.
"""
benefics = [const.VENUS, const.JUPITER]
return self.__aspectLists(benefics, aspList=... |
Returns a list with the bad aspects the object
makes to the malefics.
def aspectMalefics(self):
""" Returns a list with the bad aspects the object
makes to the malefics.
"""
malefics = [const.MARS, const.SATURN]
return self.__aspectLists(malefics, aspList=[0, 90... |
Returns true if the object last and next movement are
separations and applications to objects in list IDs.
It only considers aspects in aspList.
This function is static since it does not test if the next
application will be indeed perfected. It considers only
a snapshot ... |
Returns if the object is separating and applying to
a benefic considering good aspects.
def isAuxilied(self):
""" Returns if the object is separating and applying to
a benefic considering good aspects.
"""
benefics = [const.VENUS, const.JUPITER]
return self.__... |
Returns if the object is separating and applying to
a malefic considering bad aspects.
def isSurrounded(self):
""" Returns if the object is separating and applying to
a malefic considering bad aspects.
"""
malefics = [const.MARS, const.SATURN]
return self.__se... |
Returns if object is conjunct north node.
def isConjNorthNode(self):
""" Returns if object is conjunct north node. """
node = self.chart.getObject(const.NORTH_NODE)
return aspects.hasAspect(self.obj, node, aspList=[0]) |
Returns if object is conjunct south node.
def isConjSouthNode(self):
""" Returns if object is conjunct south node. """
node = self.chart.getObject(const.SOUTH_NODE)
return aspects.hasAspect(self.obj, node, aspList=[0]) |
Returns true if the object does not have any
aspects.
def isFeral(self):
""" Returns true if the object does not have any
aspects.
"""
planets = copy(const.LIST_SEVEN_PLANETS)
planets.remove(self.obj.id)
for otherID in planets:
otherObj = s... |
Returns the accidental dignity score of the object
as dict.
def getScoreProperties(self):
""" Returns the accidental dignity score of the object
as dict.
"""
obj = self.obj
score = {}
# Peregrine
isPeregrine = essential.isPeregrine(ob... |
Returns the non-zero accidental dignities.
def getActiveProperties(self):
""" Returns the non-zero accidental dignities. """
score = self.getScoreProperties()
return {key: value for (key, value) in score.items()
if value != 0} |
Returns the sum of the accidental dignities
score.
def score(self):
""" Returns the sum of the accidental dignities
score.
"""
if not self.scoreProperties:
self.scoreProperties = self.getScoreProperties()
return sum(self.scoreProperties.values()) |
Builds instance from dictionary of properties.
def fromDict(cls, _dict):
""" Builds instance from dictionary of properties. """
obj = cls()
obj.__dict__.update(_dict)
return obj |
Returns the Equatorial Coordinates of this object.
Receives a boolean parameter to consider a zero latitude.
def eqCoords(self, zerolat=False):
""" Returns the Equatorial Coordinates of this object.
Receives a boolean parameter to consider a zero latitude.
"""
lat = ... |
Relocates this object to a new longitude.
def relocate(self, lon):
""" Relocates this object to a new longitude. """
self.lon = angle.norm(lon)
self.signlon = self.lon % 30
self.sign = const.LIST_SIGNS[int(self.lon / 30.0)] |
Returns antiscia object.
def antiscia(self):
""" Returns antiscia object. """
obj = self.copy()
obj.type = const.OBJ_GENERIC
obj.relocate(360 - obj.lon + 180)
return obj |
Returns if this object is direct, retrograde
or stationary.
def movement(self):
""" Returns if this object is direct, retrograde
or stationary.
"""
if abs(self.lonspeed) < 0.0003:
return const.STATIONARY
elif self.lonspeed > 0:
return ... |
Returns if a longitude belongs to this house.
def inHouse(self, lon):
""" Returns if a longitude belongs to this house. """
dist = angle.distance(self.lon + House._OFFSET, lon)
return dist < self.size |
Returns the orb of this fixed star.
def orb(self):
""" Returns the orb of this fixed star. """
for (mag, orb) in FixedStar._ORBS:
if self.mag < mag:
return orb
return 0.5 |
Returns true if this star aspects another object.
Fixed stars only aspect by conjunctions.
def aspects(self, obj):
""" Returns true if this star aspects another object.
Fixed stars only aspect by conjunctions.
"""
dist = angle.closestdistance(self.lon, obj.lon)
... |
Returns a list with all objects in a house.
def getObjectsInHouse(self, house):
""" Returns a list with all objects in a house. """
res = [obj for obj in self if house.hasObject(obj)]
return ObjectList(res) |
Returns a list of objects aspecting a point
considering a list of possible aspects.
def getObjectsAspecting(self, point, aspList):
""" Returns a list of objects aspecting a point
considering a list of possible aspects.
"""
res = []
for obj in self:
... |
Returns the arc of direction between a Promissor
and Significator. It uses the generic proportional
semi-arc method.
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.
"""
... |
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
def getArc(prom, sig, mc, pos, zerolat):
""" Returns the arc of direction between a prom... |
Builds a data structure indexing the terms
longitude by sign and object.
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... |
Creates a generic entry for an object.
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 {
... |
Returns the term of an object in a sign.
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 Antiscia of an object.
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 CAntiscia of an object.
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 dexter aspect of an object.
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 conjunction or opposition aspect
of an object.
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... |
Computes the in-zodiaco and in-mundo arcs
between a promissor and a significator.
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'], s... |
Returns the arcs between a promissor and
a significator. Should uses the object creation
functions to build the objects.
def getArc(self, prom, sig):
""" Returns the arcs between a promissor and
a significator. Should uses the object creation
functions to build the objects.
... |
Returns the IDs as objects considering the
aspList and the function.
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]):
... |
Returns a list with the objects as terms.
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 sorted list with all
primary directions.
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, se... |
Returns the directions within the
min and max arcs.
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)
... |
Returns all directions to a significator.
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 promissor.
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 a deep copy of this chart.
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()
... |
Returns an object, house or angle
from the chart.
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)
... |
Returns a list with all fixed stars.
def getFixedStars(self):
""" Returns a list with all fixed stars. """
IDs = const.LIST_FIXED_STARS
return ephem.getFixedStarList(IDs, self.date) |
Returns true if House1 is the same as the Asc.
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 House10 is the same as the MC.
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.