سلام به همه.
من دنبال یه نرم افزار برای محاسبه اوقات شرعی میگشتم که minbar رو پیدا کردم.حالا توی کار باهاش یه سری مشکل برام بوجود اومده که نیاز به راهنمایی دارم.
این نرم افزار رو که اجرا میکنم شهر پیشفرضش مکه است و بعد از این که شهر تهران(مهرآباد) رو انتخاب میکنم و نرم افزار رو میبندم انگار نه انگار که تغییری رو اعمال کرده بودم،دوباره همون تنظیمات پیشفرض خودش رو داره.
حتی با دسترسی root هم تست کردم نشد.
سوای از این نرم افزار این اسکریپت پایتون رو پیدا کردم که به نظرم باحال اومد و به زبانهای زیادی هم نوشته شده که میتونید توی لینکی که داخل این اسکریپت هست پیداش کنید.
فقط برای استفاده از این اسکریپت برای انتخاب شهر باید چیکار کنم؟چه ورودیهایی بهش بدم تا رو تهران ست بشه؟
#!/usr/bin/env python
# compatible with python 2.x and 3.x
import math
import re
'''
--------------------- Copyright Block ----------------------
praytimes.py: Prayer Times Calculator (ver 2.3)
Copyright (C) 2007-2011 PrayTimes.org
Python Code: Saleem Shafi, Hamid Zarrabi-Zadeh
Original js Code: Hamid Zarrabi-Zadeh
License: GNU LGPL v3.0
TERMS OF USE:
Permission is granted to use this code, with or
without modification, in any website or application
provided that credit is given to the original work
with a link back to PrayTimes.org.
This program is distributed in the hope that it will
be useful, but WITHOUT ANY WARRANTY.
PLEASE DO NOT REMOVE THIS COPYRIGHT BLOCK.
--------------------- Help and Manual ----------------------
User's Manual:
http://praytimes.org/manual
Calculation Formulas:
http://praytimes.org/calculation
------------------------ User Interface -------------------------
getTimes (date, coordinates, timeZone [, dst [, timeFormat]])
setMethod (method) // set calculation method
adjust (parameters) // adjust calculation parameters
tune (offsets) // tune times by given offsets
getMethod () // get calculation method
getSetting () // get current calculation parameters
getOffsets () // get current time offsets
------------------------- Sample Usage --------------------------
>>> PT = PrayTimes('ISNA')
>>> times = PT.getTimes((2011, 2, 9), (43, -80), -5)
>>> times['sunrise']
07:26
'''
#----------------------- PrayTimes Class ------------------------
class PrayTimes():
#------------------------ Constants --------------------------
# Time Names
timeNames = {
'imsak' : 'Imsak',
'fajr' : 'Fajr',
'sunrise' : 'Sunrise',
'dhuhr' : 'Dhuhr',
'asr' : 'Asr',
'sunset' : 'Sunset',
'maghrib' : 'Maghrib',
'isha' : 'Isha',
'midnight' : 'Midnight'
}
# Calculation Methods
methods = {
'MWL': {
'name': 'Muslim World League',
'params': { 'fajr': 18, 'isha': 17 } },
'ISNA': {
'name': 'Islamic Society of North America (ISNA)',
'params': { 'fajr': 15, 'isha': 15 } },
'Egypt': {
'name': 'Egyptian General Authority of Survey',
'params': { 'fajr': 19.5, 'isha': 17.5 } },
'Makkah': {
'name': 'Umm Al-Qura University, Makkah',
'params': { 'fajr': 18.5, 'isha': '90 min' } }, # fajr was 19 degrees before 1430 hijri
'Karachi': {
'name': 'University of Islamic Sciences, Karachi',
'params': { 'fajr': 18, 'isha': 18 } },
'Tehran': {
'name': 'Institute of Geophysics, University of Tehran',
'params': { 'fajr': 17.7, 'isha': 14, 'maghrib': 4.5, 'midnight': 'Jafari' } }, # isha is not explicitly specified in this method
'Jafari': {
'name': 'Shia Ithna-Ashari, Leva Institute, Qum',
'params': { 'fajr': 16, 'isha': 14, 'maghrib': 4, 'midnight': 'Jafari' } }
}
# Default Parameters in Calculation Methods
defaultParams = {
'maghrib': '0 min', 'midnight': 'Standard'
}
#---------------------- Default Settings --------------------
calcMethod = 'MWL'
# do not change anything here; use adjust method instead
settings = {
"imsak" : '10 min',
"dhuhr" : '0 min',
"asr" : 'Standard',
"highLats" : 'NightMiddle'
}
timeFormat = '24h'
timeSuffixes = ['am', 'pm']
invalidTime = '-----'
numIterations = 1
offset = {}
#---------------------- Initialization -----------------------
def __init__(self, method = "MWL") :
# set methods defaults
for method, config in self.methods.items():
for name, value in self.defaultParams.items():
if not name in config['params'] or config['params'][name] is None:
config['params'][name] = value
# initialize settings
self.calcMethod = method if method in self.methods else 'MWL'
params = self.methods[self.calcMethod]['params']
for name, value in params.items():
self.settings[name] = value
# init time offsets
for name in self.timeNames:
self.offset[name] = 0
#-------------------- Interface Functions --------------------
def setMethod(self, method):
if method in self.methods:
self.adjust(self.methods[method].params)
self.calcMethod = method
def adjust(self, params):
self.settings.update(params)
def tune(self, timeOffsets):
self.offsets.update(timeOffsets)
def getMethod(self):
return self.calcMethod
def getSettings(self):
return self.settings
def getOffsets(self):
return self.offset
def getDefaults(self):
return self.methods
# return prayer times for a given date
def getTimes(self, date, coords, timezone, dst = 0, format = None):
self.lat = coords[0]
self.lng = coords[1]
self.elv = coords[2] if len(coords)>2 else 0
if format != None:
self.timeFormat = format
if type(date).__name__ == 'date':
date = (date.year, date.month, date.day)
self.timeZone = timezone + (1 if dst else 0)
self.jDate = self.julian(date[0], date[1], date[2]) - self.lng / (15 * 24.0)
return self.computeTimes()
# convert float time to the given format (see timeFormats)
def getFormattedTime(self, time, format, suffixes = None):
if math.isnan(time):
return self.invalidTime
if format == 'Float':
return time
if suffixes == None:
suffixes = self.timeSuffixes
time = self.fixhour(time+ 0.5/ 60) # add 0.5 minutes to round
hours = math.floor(time)
minutes = math.floor((time- hours)* 60)
suffix = suffixes[ 0 if hours < 12 else 1 ] if format == '12h' else ''
formattedTime = "%02d:%02d" % (hours, minutes) if format == "24h" else "%d:%02d" % ((hours+11)%12+1, minutes)
return formattedTime + suffix
#---------------------- Calculation Functions -----------------------
# compute mid-day time
def midDay(self, time):
eqt = self.sunPosition(self.jDate + time)[1]
return self.fixhour(12 - eqt)
# compute the time at which sun reaches a specific angle below horizon
def sunAngleTime(self, angle, time, direction = None):
try:
decl = self.sunPosition(self.jDate + time)[0]
noon = self.midDay(time)
t = 1/15.0* self.arccos((-self.sin(angle)- self.sin(decl)* self.sin(self.lat))/
(self.cos(decl)* self.cos(self.lat)))
return noon+ (-t if direction == 'ccw' else t)
except ValueError:
return float('nan')
# compute asr time
def asrTime(self, factor, time):
decl = self.sunPosition(self.jDate + time)[0]
angle = -self.arccot(factor + self.tan(abs(self.lat - decl)))
return self.sunAngleTime(angle, time)
# compute declination angle of sun and equation of time
# Ref: http://aa.usno.navy.mil/faq/docs/SunApprox.php
def sunPosition(self, jd):
D = jd - 2451545.0
g = self.fixangle(357.529 + 0.98560028* D)
q = self.fixangle(280.459 + 0.98564736* D)
L = self.fixangle(q + 1.915* self.sin(g) + 0.020* self.sin(2*g))
R = 1.00014 - 0.01671*self.cos(g) - 0.00014*self.cos(2*g)
e = 23.439 - 0.00000036* D
RA = self.arctan2(self.cos(e)* self.sin(L), self.cos(L))/ 15.0
eqt = q/15.0 - self.fixhour(RA)
decl = self.arcsin(self.sin(e)* self.sin(L))
return (decl, eqt)
# convert Gregorian date to Julian day
# Ref: Astronomical Algorithms by Jean Meeus
def julian(self, year, month, day):
if month <= 2:
year -= 1
month += 12
A = math.floor(year / 100)
B = 2 - A + math.floor(A / 4)
return math.floor(365.25 * (year + 4716)) + math.floor(30.6001 * (month + 1)) + day + B - 1524.5
#---------------------- Compute Prayer Times -----------------------
# compute prayer times at given julian date
def computePrayerTimes(self, times):
times = self.dayPortion(times)
params = self.settings
imsak = self.sunAngleTime(self.eval(params['imsak']), times['imsak'], 'ccw')
fajr = self.sunAngleTime(self.eval(params['fajr']), times['fajr'], 'ccw')
sunrise = self.sunAngleTime(self.riseSetAngle(self.elv), times['sunrise'], 'ccw')
dhuhr = self.midDay(times['dhuhr'])
asr = self.asrTime(self.asrFactor(params['asr']), times['asr'])
sunset = self.sunAngleTime(self.riseSetAngle(self.elv), times['sunset'])
maghrib = self.sunAngleTime(self.eval(params['maghrib']), times['maghrib'])
isha = self.sunAngleTime(self.eval(params['isha']), times['isha'])
return {
'imsak': imsak, 'fajr': fajr, 'sunrise': sunrise, 'dhuhr': dhuhr,
'asr': asr, 'sunset': sunset, 'maghrib': maghrib, 'isha': isha
}
# compute prayer times
def computeTimes(self):
times = {
'imsak': 5, 'fajr': 5, 'sunrise': 6, 'dhuhr': 12,
'asr': 13, 'sunset': 18, 'maghrib': 18, 'isha': 18
}
# main iterations
for i in range(self.numIterations):
times = self.computePrayerTimes(times)
times = self.adjustTimes(times)
# add midnight time
if self.settings['midnight'] == 'Jafari':
times['midnight'] = times['sunset'] + self.timeDiff(times['sunset'], times['fajr']) / 2
else:
times['midnight'] = times['sunset'] + self.timeDiff(times['sunset'], times['sunrise']) / 2
times = self.tuneTimes(times)
return self.modifyFormats(times)
# adjust times in a prayer time array
def adjustTimes(self, times):
params = self.settings
tzAdjust = self.timeZone - self.lng / 15.0
for t,v in times.items():
times[t] += tzAdjust
if params['highLats'] != 'None':
times = self.adjustHighLats(times)
if self.isMin(params['imsak']):
times['imsak'] = times['fajr'] - self.eval(params['imsak']) / 60.0
# need to ask about 'min' settings
if self.isMin(params['maghrib']):
times['maghrib'] = times['sunset'] - self.eval(params['maghrib']) / 60.0
if self.isMin(params['isha']):
times['isha'] = times['maghrib'] - self.eval(params['isha']) / 60.0
times['dhuhr'] += self.eval(params['dhuhr']) / 60.0
return times
# get asr shadow factor
def asrFactor(self, asrParam):
methods = {'Standard': 1, 'Hanafi': 2}
return methods[asrParam] if asrParam in methods else self.eval(asrParam)
# return sun angle for sunset/sunrise
def riseSetAngle(self, elevation = 0):
elevation = 0 if elevation == None else elevation
return 0.833 + 0.0347 * math.sqrt(elevation) # an approximation
# apply offsets to the times
def tuneTimes(self, times):
for name, value in times.items():
times[name] += self.offset[name] / 60.0
return times
# convert times to given time format
def modifyFormats(self, times):
for name, value in times.items():
times[name] = self.getFormattedTime(times[name], self.timeFormat)
return times
# adjust times for locations in higher latitudes
def adjustHighLats(self, times):
params = self.settings
nightTime = self.timeDiff(times['sunset'], times['sunrise']) # sunset to sunrise
times['imsak'] = self.adjustHLTime(times['imsak'], times['sunrise'], self.eval(params['imsak']), nightTime, 'ccw')
times['fajr'] = self.adjustHLTime(times['fajr'], times['sunrise'], self.eval(params['fajr']), nightTime, 'ccw')
times['isha'] = self.adjustHLTime(times['isha'], times['sunset'], self.eval(params['isha']), nightTime)
times['maghrib'] = self.adjustHLTime(times['maghrib'], times['sunset'], self.eval(params['maghrib']), nightTime)
return times
# adjust a time for higher latitudes
def adjustHLTime(self, time, base, angle, night, direction = None):
portion = self.nightPortion(angle, night)
diff = self.timeDiff(time, base) if direction == 'ccw' else self.timeDiff(base, time)
if math.isnan(time) or diff > portion:
time = base + (-portion if direction == 'ccw' else portion)
return time
# the night portion used for adjusting times in higher latitudes
def nightPortion(self, angle, night):
method = self.settings['highLats']
portion = 1/2.0 # midnight
if method == 'AngleBased':
portion = 1/60.0 * angle
if method == 'OneSeventh':
portion = 1/7.0
return portion * night
# convert hours to day portions
def dayPortion(self, times):
for i in times:
times[i] /= 24.0
return times
#---------------------- Misc Functions -----------------------
# compute the difference between two times
def timeDiff(self, time1, time2):
return self.fixhour(time2- time1)
# convert given string into a number
def eval(self, st):
val = re.split('[^0-9.+-]', str(st), 1)[0]
return float(val) if val else 0
# detect if input contains 'min'
def isMin(self, arg):
return isinstance(arg, str) and arg.find('min') > -1
#----------------- Degree-Based Math Functions -------------------
def sin(self, d): return math.sin(math.radians(d))
def cos(self, d): return math.cos(math.radians(d))
def tan(self, d): return math.tan(math.radians(d))
def arcsin(self, x): return math.degrees(math.asin(x))
def arccos(self, x): return math.degrees(math.acos(x))
def arctan(self, x): return math.degrees(math.atan(x))
def arccot(self, x): return math.degrees(math.atan(1.0/x))
def arctan2(self, y, x): return math.degrees(math.atan2(y, x))
def fixangle(self, angle): return self.fix(angle, 360.0)
def fixhour(self, hour): return self.fix(hour, 24.0)
def fix(self, a, mode):
if math.isnan(a):
return a
a = a - mode * (math.floor(a / mode))
return a + mode if a < 0 else a
#---------------------- prayTimes Object -----------------------
prayTimes = PrayTimes()
#-------------------------- Test Code --------------------------
# sample code to run in standalone mode only
if __name__ == "__main__":
from datetime import date
print('Prayer Times for today in Waterloo/Canada\n'+ ('='* 41))
times = prayTimes.getTimes(date.today(), (43, -80), -5);
for i in ['Fajr', 'Sunrise', 'Dhuhr', 'Asr', 'Maghrib', 'Isha', 'Midnight']:
print(i+ ': '+ times[i.lower()])
موضوع: تجربه کار با نرم افزار minbar (دفعات بازدید: 545 بار)
