コード例 #1
0
ファイル: Main.py プロジェクト: EKOsh/TeleMonBot
def co_list(chat_id, command, globrand):
    if (command == 'Where are you?'):
        import geocoder
        import urllib
        url = 'http://myexternalip.com/raw'
        bot.sendLocation(chat_id, geocoder.ip(urllib.urlopen(url).read()).latlng[0], geocoder.ip(urllib.urlopen(url).read()).latlng[1])
    mystring = command
    if (mystring.partition(" ")[0] == 'Say,'):
        vari = mystring.partition(" ")[2]
        if globrand <= 5:
            bot.sendMessage(chat_id, vari.rpartition('or')[0])
        else:
            bot.sendMessage(chat_id, vari.rpartition('or')[2])
    if (command == 'Where are you all?'):
        bot.sendMessage(chat_id, 'I am here!')
    if (command == 'Screenshot'):
        app = QApplication(sys.argv)
        QPixmap.grabWindow(QApplication.desktop().winId()).save('screenshot.jpg', 'jpg')
        bot.sendPhoto(chat_id, open('screenshot.jpg', 'rb'))
    if (command == 'RAM usage'):
        bot.sendMessage(chat_id, 'Nearly {}% of RAM is used.'.format(virtual_memory().percent))
    if (command == 'Who is your creator?'):
        bot.sendMessage(chat_id, 'His nick is E_KOsh...')
        bot.sendMessage(chat_id, "You might want to write him... Don't be so shy - @E_KOsh")
    if (command == 'CPU usage'):
        bot.sendMessage(chat_id, "About {}% of my CPU power is used.".format(cpu_percent()))
    if (command == 'What is the time?'):
        bot.sendMessage(chat_id, str(datetime.datetime.now()))
    if (command == 'Uptime'):
        u = round(uppp() / 3600, 1)
        bot.sendMessage(chat_id, 'I am already working for {} hours.'.format(u))
コード例 #2
0
def emailOpen(e):
	d = {}
	if request.cookies.get('LATrackingID'):
		a = modules.getModel(models.App, appid = request.cookies.get('LATrackingID'))
		d['app_id'] = a.id
	d['private_ip'] = request.environ.get('REMOTE_ADDR')
	d['public_ip'] = request.environ.get('HTTP_X_FORWARDED_FOR')
	d['full_url'] = request.environ.get('HTTP_REFERER', '').strip().lower()
	email = db.session.query(models.Email).filter_by(emailid=e).first()
	if email:
		d['email_id'] = email.id
	else:
		return jsonify(**{'status':'failure', 'description':'no such email found'})
	if d['public_ip']:
		g = geocoder.ip(d['public_ip'])
		d['lat'], d['lng'] = g.latlng
		d['city'] = g.city
		d['country'] = g.country
		d['state'] = g.state
	d['user_agent'] = request.environ.get('HTTP_USER_AGENT')
	if d['user_agent']:
		user_agent = parse(d['user_agent'])
		d['browser'] = user_agent.browser.family
		d['is_bot'], d['is_mobile'], d['is_tablet'], d['is_pc'] = user_agent.is_bot, user_agent.is_mobile, user_agent.is_tablet, user_agent.is_pc
	p = models.Visit(**d)
	p.date = datetime.now()
	db.session.add(p)
	db.session.commit()
	return jsonify(success=True, description='successfully tracked email')
コード例 #3
0
def _redirect(l):
	d = {}
	d['private_ip'] = request.environ.get('REMOTE_ADDR')
	d['public_ip'] = request.environ.get('HTTP_X_FORWARDED_FOR')
	d['full_url'] = request.environ.get('HTTP_REFERER', '').strip().lower()
	if request.cookies.get('LATrackingID'):
		a = modules.getModel(models.App, appid = request.cookies.get('LATrackingID'))
		d['app_id'] = a.id
	link = db.session.query(models.Link).filter_by(linkid=l).first()
	if link:
		red_url = link.url
		d['link_id'] = link.id
		error = 'successfully tracked link'
	else:
		return jsonify(**{'status':'failure', 'description':'no such link found'})
	if d['public_ip']:
		g = geocoder.ip(d['public_ip'])
		d['lat'], d['lng'] = g.latlng
		d['city'] = g.city
		d['country'] = g.country
		d['state'] = g.state
	d['user_agent'] = request.environ.get('HTTP_USER_AGENT')
	if d['user_agent']:
		user_agent = parse(d['user_agent'])
		d['browser'] = user_agent.browser.family
		d['is_bot'], d['is_mobile'], d['is_tablet'], d['is_pc'] = user_agent.is_bot, user_agent.is_mobile, user_agent.is_tablet, user_agent.is_pc
	p = models.Visit(**d)
	p.date = datetime.now()
	db.session.add(p)
	db.session.commit()
	return redirect(red_url, code=302)
コード例 #4
0
ファイル: utils.py プロジェクト: victorliun/pace_insight_car
def parse_args(request):
    """
    Parse args from request, return dict.
    """

    comp_form = dict(zip(
        request.GET.keys(),
        request.GET.values()))
    params = {}

    params['browser_type'] = request.META['HTTP_USER_AGENT']
    ip = get_ip(request)
    params['ip_addr'] = ip
    geo = geocoder.ip(ip)
    params['city'] = geo.city
    params['country'] = geo.country

    params['monthly_budget'] = int(comp_form['monthlyBudget'])
    params['discount'] = int(comp_form.get('discount', 0))
    params['list_price'] = int(comp_form['totalPrice'])
    params['extra_price'] = int(comp_form.get('extraPrice', 0))
    params['depreciation_id'] = int(comp_form['depreciationId'])
    params['tax'] = int(comp_form['tax'])

    params['px_amount'] = int(comp_form.get('pxAmount', 0))
    params['deposit_amount'] = int(comp_form.get('depositAmount', 0))

    params['term'] = int(comp_form['term'])
    if comp_form.get('foHP') == 'True':
        hp_data = json.loads(comp_form.get('hp').decode('cp1252'))
        params['hp'] = True
        params['hp_term'] = hp_data.get('term', 0)
        params['hp_loan_rate'] = hp_data['loan_at'] / 100.0

    if comp_form.get('foPCP') == 'True':
        pcp_data = json.loads(comp_form.get('pcp').decode('cp1252'))
        params['pcp'] = True
        params['pcp_term'] = pcp_data.get('term', 0)
        params['pcp_loan_rate'] = pcp_data['loan_at'] / 100.0
        params['pcp_ballon_value'] = pcp_data['ballon_value']

    if comp_form.get('foLease') == 'True':
        lease_data = json.loads(comp_form.get('lease').decode('cp1252'))
        params['lease'] = True
        params['lease_term'] = lease_data.get('term')
        params['lease_extras'] = lease_data.get('extras', 0)
        params['lease_initial_payment'] = lease_data['initial_payment']
        params['lease_monthly_payment'] = lease_data['monthly']
        params['lease_predicted_mileage'] = lease_data.get('actual_annual', 0)
        params['lease_included_mileage'] = lease_data.get('include_mileages', 0)
        params['lease_excess_mile_price'] = lease_data.get('price_per_mile', 0)

    if comp_form.get('foLoan') == 'True':
        loan_data = json.loads(comp_form.get('loan').decode('cp1252'))
        params['loan'] = True
        params['loan_term'] = loan_data.get('term', 0)
        params['loan_loan_rate'] = loan_data['loan_at'] / 100.0
        params['loan_loan_at_end'] = loan_data.get('loan_at_end',0)

    return params
コード例 #5
0
def get_temperature():
    g = geocoder.ip('me')
    owm = pyowm.OWM('65a34e19f4ad83823846b8fd1a1813fd')
    location  = g.city+","+g.country
    observation = owm.weather_at_place(location)
    w = observation.get_weather()
    temperature = w.get_temperature('celsius')['temp']
    return temperature
コード例 #6
0
ファイル: viewmixins.py プロジェクト: guialante/mozio
 def get_context_data(self, **kwargs):
     context = super(LocationMixin, self).get_context_data(**kwargs)
     visitor_ip = self.request.META.get('REMOTE_ADDR', None)
     latlng = {'lat': 37.774929, 'lng': -122.419416}
     if visitor_ip is not None:
         g = geocoder.ip(visitor_ip)
         if g.lat is not None and g.lng is not None:
             latlng.update(lat=g.lat, lng=g.lng)
     context['latlng'] = latlng
     return context
コード例 #7
0
def addPeer(hostport, db):
    ip, port = url_to_ip_port( hostport )
    ipport = ip+':'+str(port)
    if ip not in ['127.0.0.1', '::1']:
        cursor = db.execute('''SELECT hostname FROM hosts WHERE hostname = ?''',(ipport,))
        if not len(cursor.fetchall()):
            g = geocoder.ip(ip)
            country = pycountry.countries.get(alpha_2=g.country)
            cursor = db.execute('''INSERT INTO hosts(hostname, lat, lng, city, state, country) VALUES(?,?,?,?,?,?)''',(ipport, g.lat, g.lng, g.city, g.state, country.name))
            db.commit()   
コード例 #8
0
ファイル: models.py プロジェクト: harshalgalgale/lokator
def get_location_by_ip(ip):
    location = None
    loc = geocoder.ip(ip)
    if loc and loc.ok:
        location, created = Location.objects.get_or_create(location=Point(loc.lng, loc.lat), defaults={'address': loc.address})
    else:
        record = gip.record_by_addr(ip)
        if record:
            location, created = Location.objects.get_or_create(location=Point(record.get('longitude'), record.get('latitude')), defaults={
                'address': '%s, %s'%(record.get('city'), record.get('country_name')) if record.get('city') else record.get('country_name')
            })
    return location
コード例 #9
0
ファイル: jsonpserver.py プロジェクト: vesellov/callfeed.net
def ip_to_location(ip):
    """
    Получение геоданных об ip-адресе. Подставляется в статистику звонков.
    :param ip: ip-адрес клиента
    :return: геоданные по ip-адресу
    """
    if ip in (None, ''):
        return ''
    import geocoder
    ret = geocoder.ip(ip).address
    # print('ip_to_location: %s -> %s' % (ip, str(ret)))
    return ret
コード例 #10
0
def get_my_ip():
	if request.args.get('ip'):
		ip = request.args['ip']
	else:
		fwd = request.environ.get('HTTP_X_FORWARDED_FOR', None)
		if fwd is None:
			fwd = request.environ.get('REMOTE_ADDR')
		ip = fwd.split(',')[0]
	g = geocoder.ip(ip)
	tz = g.timezone
	offset = int(timezone(tz).localize(datetime.now()).strftime('%z'))/100
	return jsonify(**{'ip': ip, 'offset':offset, 'tz':tz, 'city':g.city, 'country':g.country, 'state':g.state})
コード例 #11
0
ファイル: views.py プロジェクト: shellajt/TextbookyWebApp
def listing_list(request):
	
    g = geocoder.ip('me')
    lat= g.latlng[0]
    lng = g.latlng[1]
		
    c = connection.cursor()
    try:
        results = Listings.objects.raw('SELECT * FROM getCloseListings(%s, %s)', [lat, lng])
        #results = c.fetchall()
        print(results)
    finally:
        c.close()
    return render(request, 'listings/listing_list.html', {'listings': results})
コード例 #12
0
ファイル: Weather.py プロジェクト: faustocarrera/weather-cli
 def get_geolocation(ipaddress):
     "check latitude and longitude of the ip"
     result = {'city': None, 'lat': 0, ' lon': 0}
     try:
         # force disable insecure request warning
         requests.packages.urllib3.disable_warnings()
         match = geocoder.ip(ipaddress)
         result['location'] = '%s, %s' % (match.city, match.country)
         result['lat'] = float(match.lat)
         result['lon'] = float(match.lng)
     except ValueError as error:
         print error
         sys.exit(1)
     return result
コード例 #13
0
def calc_my_position_ip(output=MY_POSITION_FILENAME):
    setup_output(output)

    if not config.get('activated', False):
        logger.info('Exiting: not activated')
        return

    logger.info('Waiting %s seconds...', WAIT_BEFORE_QUERY)
    time.sleep(WAIT_BEFORE_QUERY)
    logger.info('Querying the server about my ip...')
    response = geocoder.ip('me')
    logger.info('LatLng: %s', response.latlng)
    logger.info('Place: %s', response.address)

    return calc_my_position_address(response.address, output)
コード例 #14
0
ファイル: window.py プロジェクト: thalida/thalida.com
    def _get_weather(self, request, force_update, weather_cookie):
        """Get Current Weather Based on IP Address

        Based on the current ip location, getthe current weather (or use NY if location
        is not available.) Save that data to a cookie to reduce # of api calls.

        Arguments:
            request -- A Flast Request
            force_update {bool} -- Should we force update the weather data
            weather_cookie -- Stored weather data
        """

        # Get current weather for location based on IP
        if weather_cookie and not force_update:
            from_cookie = True;
            current_weather = json.loads(weather_cookie)
        else:
            from_cookie = False

            # fallback latitute/longitude data
            test_latlngs = {
                'newyork': [40.7081, -73.9571],
                'hawaii': [19.8968, 155.5828],
                'trinidad': [10.65, -61.5167],
                'sweden': [60.1282, 18.6435],
                'australia': [25.2744, 133.7751],
            }
            default_latlng = test_latlngs['newyork']

            # Get the visitors IP and lat/lng for that IP
            ip = request.headers.get('X-Forwarded-For', request.remote_addr)
            geo = geocoder.ip(ip) if ip != '127.0.0.1' else None
            lat, lng = geo.latlng if geo and len(geo.latlng) == 2 else default_latlng

            # Use Darksky to get the current forcast for that lat/lng
            geo_forecast = forecast(FORECAST_KEY, lat, lng)

            # Get and format the current weather
            daily_weather = geo_forecast['daily']['data'][0]
            current_weather = geo_forecast['currently']
            current_weather['timezone'] = geo_forecast['timezone']
            current_weather['units'] = geo_forecast['flags']['units'] # F or C
            current_weather['sunriseTime'] = daily_weather['sunriseTime']
            current_weather['sunsetTime'] = daily_weather['sunsetTime']
            current_weather['ip'] = ip
            current_weather['lat_lng'] = [lat, lng]

        return {'current': current_weather, 'from_cookie': from_cookie}
コード例 #15
0
def get_weather(location):

    if location is None:
        g = geocoder.ip('me')
    else:
        g = geocoder.google(location)

    url = "https://api.darksky.net/forecast/{}/{},{}?exclude=minutely,hourly,alerts,flags?UNITS={}".format(DARKSKY_API_KEY, g.lat, g.lng, UNITS)
    response = requests.get(url).json()
    table_week = [["", "", "HI", "at", "LO", "at", "", ""]]

    for day in response['daily']['data']:
        date = datetime.datetime.fromtimestamp(int(day['time'])).strftime('%a %b %-d')
        summary = day['summary']
        max_temp = temp_format(colors.RED, day['temperatureMax'])
        max_temp_time = readable_time(day['temperatureMaxTime'])
        min_temp = temp_format(colors.BLUE, day['temperatureMin'])
        min_temp_time = readable_time(day['temperatureMinTime'])
        percip_chance = str(int(day['precipProbability'] * 100)) + "%"
        try:
            percip_type = day['precipType'].title()
        except KeyError:
            percip_type = ""
        table_day = [date, summary, max_temp, max_temp_time, min_temp, min_temp_time, percip_chance, percip_type]
        table_week.append(table_day)

    table_week[1][0] = colors.BOLD + colors.GREEN + "* Today *" + colors.ENDC

    title = colors.BOLD + " {}, {} - Current Temp: {} ".format(g.city, g.state, (str(int(response['currently']['temperature'])) + UNIT_LETTER)) + colors.ENDC

    # AsciiTable
    table_instance = AsciiTable(table_week, title)
    table_instance.justify_columns[2] = 'right'

    # Output
    print("\n" + colors.BOLD + response['daily']['summary'] + colors.ENDC + "\n")
    print(table_instance.table)
コード例 #16
0
def page_not_found(error):
    with requests.Session() as session:
        requester_ip = request.access_route[0]

        if requester_ip == '127.0.0.1':
            place, latlng, elev = 'nc', [35.6921, -80.4357], 218.2
            address: str = u'On Library Park: 35\N{DEGREE SIGN} 41\' 31.9\"N 80\N{DEGREE SIGN} 26\' 8.67\"W'

        else:
            place, latlng = 'geocode', geocoder.ip(requester_ip, key=GOOGLE_API_KEY).latlng

        requester_geocode = geocoder.google(latlng, key=GOOGLE_API_KEY, method='reverse', session=session)

        # Use the defined address, implies we are using a static location, if undefined make it the geocoded one.
        try:
            address
        except NameError:
            address = str(requester_geocode.address)

        # Use the defined elevation, implies we are using a static location, if undefined make it the geocoded one.
        try:
            requester_geocode.elevation = lambda: None
            requester_geocode.elevation.meters = lambda: None
            setattr(requester_geocode.elevation, 'meters', elev)
        except NameError:
            requester_geocode.elevation = geocoder.elevation(latlng, key=GOOGLE_API_KEY, session=session)

        # Get the timezone
        requester_geocode.timeZoneId = geocoder.timezone(latlng, key=GOOGLE_API_KEY, session=session).timeZoneId

    return render_template('404.html',
                           place=place,
                           address=address,
                           latlng=latlng,
                           elevation=requester_geocode.elevation.meters,
                           ip=requester_ip), 404
コード例 #17
0
def showMaps(request):
    g = geocoder.ip('me')
    map = folium.Map(location=g.latlng, zoom_start=15)
    maps = map._repr_html_()
    return render(request, 'home.html', {'map': maps})
コード例 #18
0
import os
import sys
import json
import mysql.connector
import geocoder
import googlemaps

g = geocoder.ip('me').latlng
#"57.8765","1.98765"


def hos():
    places = gmaps.places_nearby(location=(co[0], co[1]),
                                 rank_by='distance',
                                 type='hospital',
                                 name='Hospital',
                                 language='en')
    print(places['results'][0]['plus_code']['global_code'])
    hospital = []
    for i in range(len(places['results'])):
        t = places['results'][i]['name']
        if ('hospital' in t.lower()):
            hospital.append([t, places['results'][i]['id']])
    return hospital


def pol(co):
    places = gmaps.places_nearby(location=(co[0], co[1]),
                                 rank_by='distance',
                                 type='police',
                                 name='police',
コード例 #19
0
ファイル: BeyondPing.py プロジェクト: vsrivatsa25/BeyondPing
                            float(vals[i][12]),
                            c=colorpicker(int(vals[i][10])),
                            s=30,
                            zorder=2,
                            alpha=1)
                plt.annotate(vals[i][3] + " " + vals[i][2] + "\n" +
                             "Latency:" + vals[i][10] + "ms",
                             (float(vals[i][11]), float(vals[i][12])),
                             size=6)
            except:
                pass
        df_csv._set_value(i, 'response_time', vals[i][10])
        df_csv._set_value(i, 'longitude', vals[i][11])
        df_csv._set_value(i, 'latitude', vals[i][12])

    self_loc = geocoder.ip('me')
    map.scatter(self_loc.lng, self_loc.lat, c='blue', s=90, zorder=3, alpha=1)
    plt.annotate("I am here!", (self_loc.lng, self_loc.lat), size=7)
    df_csv.to_csv('nameservers.csv', index=False)
    print('That took {} seconds...'.format(time.time() - starttime))
    print("IP Data inserted successfully into table...")
    print("Plotting Map...")
    plt.show()
    print("Map Closed...")

    # Created by : Vrishab V Srivatsa
    # Credits : Geocoder API, https://public-dns.info
    # Inspired by a Cloudflare internship application task
    # Please credit if used for your personal/academic uses
    # Twitter: @vsrivatsa25 https://twitter.com/vsrivatsa25?lang=da
    # Instagram: @vsrivatsa25 https://www.instagram.com/vsrivatsa25/?hl=en
コード例 #20
0
def get_current_location():
    import geocoder

    g = geocoder.ip("me")
    return g.y, g.x
コード例 #21
0
def current_loc(location):
    g = geocoder.ip('me')
    latlng = g.latlng
    lat = str(latlng[0])
    longi = str(latlng[1])
    return lat, longi
コード例 #22
0
 def getCenter(self):
     data = geocoder.ip('me').latlng
コード例 #23
0
def get_address():
    g = geocoder.ip('me')
    return g.address
コード例 #24
0
def get_latlng():
    g = geocoder.ip('me')
    new= str(g.latlng[0])+ " "+ str(g.latlng[1])
    return new
コード例 #25
0
def insert():
	error = 'tracked visit. Nothing more to see here'
	status = 'success'
	try:
		d = {}
		d['private_ip'] = request.environ.get('REMOTE_ADDR')
		d['public_ip'] = request.environ.get('HTTP_X_FORWARDED_FOR')
		d['full_url'] = request.environ.get('HTTP_REFERER', '').strip().lower()
		if 'appid' in request.form:
			if 'event' in request.form:
				d['visit_id'] = db.session.query(models.Visit).filter_by(full_url=d['full_url'], public_ip=d['public_ip'], private_ip=d['private_ip']).order_by('-id').first().id
				d['event_type'] = request.form['event_type'].lower()
				d['element_id'] = request.form['element_id'].lower()
				d['element_type'] = request.form['element_type'].lower()
				d['element_tag'] = request.form['element_tag'].lower()
				if 'public_ip' in d: del d['public_ip']
				if 'private_ip' in d: del d['private_ip']
				if 'full_url' in d: del d['full_url']
				e = models.Event(**d)
				e.date = datetime.now()
				db.session.add(e)
				db.session.commit()
				return jsonify(**{'status':'success', 'description':'event recorded'})
			app = modules.getModel(models.App, appid = request.form['appid'])
			if not app:
				return jsonify(**{'status':'failure', 'description':'no app found with that id'})
			if app.website.base not in d['full_url']:
				return jsonify(**{'status':'failure', 'description':'app is for a different website'})
			ur = d['full_url'].replace('https://','').replace('http://','').replace('www.','').lower().strip()
			if '/' not in ur: ur += '/'
			base, d['after'] = ur[:ur.index('/')], ur[ur.index('/')+1:]
			d['website_id'] = app.website.id
			if len(d['after']) <= 1:
				d['after'] = None
			elif d['after'][-1] == '/':
				d['after'] = d['after'][:-1]
			if '?' in ur:
				if d['after']:
					d['after'] = d['after'].split('?')[0]
				d['gets'] = ur.split('?')[1]
				if len(d['gets']) <= 1:
					d['gets'] = None
			d['secure'] = 'https://' in d['full_url']
		else: return jsonify(**{'status':'failure', 'description':'no recognized action taken'})
		if d['public_ip']:
			g = geocoder.ip(d['public_ip'])
			d['lat'], d['lng'] = g.latlng
			d['city'] = g.city
			d['country'] = g.country
			d['state'] = g.state
		d['user_agent'] = request.environ.get('HTTP_USER_AGENT')
		if d['user_agent']:
			user_agent = parse(d['user_agent'])
			d['browser'] = user_agent.browser.family
			d['is_bot'], d['is_mobile'], d['is_tablet'], d['is_pc'] = user_agent.is_bot, user_agent.is_mobile, user_agent.is_tablet, user_agent.is_pc
		p = models.Visit(**d)
		p.date = datetime.now()
		db.session.add(p)
		db.session.commit()
	except Exception as e:
		error = repr(e)
		status = 'failure'
	return jsonify(**{'status':status, 'description':error})
コード例 #26
0
ファイル: iss.py プロジェクト: FelipeACXavier/ISS_Tracker
def find_lng(x, y, z):
    return math.atan(z / math.sqrt(x + y))


# ------------------------------------------------------------------- #
# Global variables
planets = ['ISS', 'Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Neptune', 'Uranus', 'Pluto', 'Sun']
my_coord = [0, 0, 0]
obj_coord = [0, 0, 0]
obj = ''
message = ''
earthradius = 6371

# Gets my coordinates
me = geocoder.ip('me')

# Get date and time of request and format it to print
timeNow = strftime("%Y/%m/%d/%H/%M/%S").split('/', 5)
date = 'Date: ' + timeNow[2] + '/' + timeNow[1] + '/' + timeNow[0] + ' - ' + timeNow[3] + ':' + timeNow[4] + ':' + timeNow[5]
print(date)

# ------------------------------------------------------------------- #
# ----------------------- Set server -------------------------------- #
# Your IP address
HOST = '192.168.1.69'
PORT = 8080

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
コード例 #27
0
def print_ephemeris():
    # set the location to report for
    with requests.Session() as session:
        requester_ip = request.access_route[0]

        if str(request.path) == '/nc' or str(request.path) == '/erikshus':
            place, latlng, elev = 'nc', [35.6921, -80.4357], 218.2
            address: str = u'On Library Park: 35\N{DEGREE SIGN} 41\' 32\"N 80\N{DEGREE SIGN} 26\' 9\"W'
        elif str(request.path) == '/gammelhus':
            place, latlng, elev = 'gammelhus', [42.1064, -76.2624], 248.7168
            address: str = u'Under the streetlamp: 42\N{DEGREE SIGN} 06\' 23\"N 76\N{DEGREE SIGN} 15\' 45\"W'
        elif str(request.path) == '/kopernik':
            place, latlng, elev = 'kopernik', [42.0020, -76.0334], 528
            address: str = u'Kopernik Observatory: 42\N{DEGREE SIGN} 0\' 7\"N 76\N{DEGREE SIGN} 2\' 0\"W'
        elif str(request.path) == '/deetop':
            place, latlng, elev = 'deetop', [41.9700, -75.6700], 284
            address: str = u'Dee-Top Observatory: 41\N{DEGREE SIGN} 58\' 12\"N 75\N{DEGREE SIGN} 40\' 12\"W'
        elif str(request.path) == '/stjohns':
            place, latlng, elev = 'stjohns', [47.5675, -52.7072], 83
            address: str = u'St. John\'s: 47\N{DEGREE SIGN} 34\' 3\"N 52\N{DEGREE SIGN} 42\' 26\"W'
        elif str(request.path) == '/greenwich':
            place, latlng, elev = 'greenwich', [51.4768, -0.0005], 47.1526
            address: str = u'Greenwich Observatory: 51\N{DEGREE SIGN} 28\' 38\"N 0\N{DEGREE SIGN} 0\' 0\"'
        else:
            if requester_ip == '127.0.0.1':
                place, latlng, elev = 'nc', [35.6921, -80.4357], 218.2
                address: str = u'On Library Park: 35\N{DEGREE SIGN} 41\' 32\"N 80\N{DEGREE SIGN} 26\' 9\"W'
            else:
                place, latlng = 'geocode', geocoder.ip(requester_ip, key=GOOGLE_API_KEY, session=session).latlng

        # Start with a discovered geocode.
        requester_geocode = geocoder.google(latlng, method='reverse', key=GOOGLE_API_KEY, session=session)

        # Use the defined address, implies we are using a static location, if undefined make it the geocoded one.
        try:
            address
        except NameError:
            address = str(requester_geocode.address)

        # Use the defined elevation, implies we are using a static location, if undefined make it the geocoded one.
        try:
            requester_geocode.elevation = lambda: None
            requester_geocode.elevation.meters = lambda: None
            setattr(requester_geocode.elevation, 'meters', elev)
        except NameError:
            requester_geocode.elevation = geocoder.elevation(latlng, key=GOOGLE_API_KEY, session=session)

        # Get the timezone
        requester_geocode.timeZoneId = geocoder.timezone(latlng, key=GOOGLE_API_KEY, session=session).timeZoneId

    # noinspection PyPep8
    return render_template('print_times.html',
                           place=place,
                           sunset_string=twilight('sunset', requester_geocode),
                           sunrise_string=twilight('sunrise', requester_geocode),
                           civil_end_string=twilight('civil_end', requester_geocode),
                           civil_begin_string=twilight('civil_begin', requester_geocode),
                           nautical_end_string=twilight('nautical_end', requester_geocode),
                           nautical_begin_string=twilight('nautical_begin', requester_geocode),
                           amateur_end_string=twilight('amateur_end', requester_geocode),
                           amateur_begin_string=twilight('amateur_begin', requester_geocode),
                           astro_end_string=twilight('astronomical_end', requester_geocode),
                           astro_begin_string=twilight('astronomical_begin', requester_geocode),
                           moonrise_string=twilight('moonrise', requester_geocode),
                           moonset_string=twilight('moonset', requester_geocode),
                           moon_phase_string=twilight('moon_phase', requester_geocode),
                           moonset_ante_astro_noon_p=twilight('moonset_ante_astro_noon_p', requester_geocode),
                           address=address,
                           latlng=latlng,
                           elevation=requester_geocode.elevation.meters,
                           ip=requester_ip)
コード例 #28
0
def conversation(matched_index):
    global user
    user = db_inf['name'][matched_index]
    if matched_index == 0:
        print('welcome admin,how can i help you')
        say('welcome admin,how can i help you')
    else:
        print('welcome to personel jarvis,  how can i help you')
        say('welcome to personel jarvis,  how can i help you')

    while True:
        word = speech_recognizer()
        print('Jarvis :recognized word :', word)
        log_(word, False)
        res = ''
        if 'google' in word or 'browser' in word or 'youtube' in word or 'tell me' in word or 'what' in word or 'recomended' in word or 'search' in word or 'website' in word:
            browser(word)
            word = mouse_()
        elif 'stop song' in word or 'play' in word or 'paly song' in word:
            mouse_(word)
        elif 'who are you' in word or 'give your intro' in word:
            res = "i'm a personel jarvis of pankaj.i can also help you by providing some imformation if you want"
            print('Jarvis :' + res)
            say(res)
        elif 'hello' in word or 'hi' in word:
            res = 'hii!...how can i help you'
            print('jarvis :' + res)
            say(res)
        elif 'manufacturer' in word:
            res = 'pankaj kumar,he made me durring summer training in techienest,jaipur by saurabh sir.at that time he was persuing B.tech from nit jalandhar'
            print('Jarvis :' + res)
            say(res)
        elif 'how are you' in word:
            res = 'fine and i am not intrested in know your f*****g mood,want any help than stay otherwise get out from here'
            print('Jarvis :' + res)
            say(res)
        elif "wikipedia" in word:
            Wikipedia()

        elif "today's date" in word or 'date' in word:
            d = str(date.today())
            res = "today's date is :" + d
            print('Jarvis :' + res)
            say(res)
        elif 'time' in word or 'current time' in word:
            time = t.ctime()
            time = str(time.split(' ')[4])
            res = 'current time :' + time
            print('Jarvis :' + res)
            say('current time is' + str(time.split(':')[0:2]))

        elif "weather" in word or "temperature" in word:
            say("Tell your city")
            log_("Tell your city")
            city_name = speech_recognizer()
            print("city you said is", city_name)
            #city_name=input("enter city name to confirm")
            api_key = "cca979ed5fb2c8d3a9c99594191482f9"
            base_url = "http://api.openweathermap.org/data/2.5/weather?"
            complete_url = base_url + "appid=" + api_key + "&q=" + city_name
            json_data = requests.get(complete_url).json()
            try:
                temp = json_data['main']
                temp = str(int(int(temp['temp']) - 273.15))
                temp1 = json_data['weather'][0]['description']
                d = " Current Temperature in " + city_name + " is " + temp + " degree celsius with " + temp1
                print("Jarvis : ", d)
                say(d)
                log_(d)
            except KeyError:
                print("Key invalid or city not found")

        elif "location" in word:
            g = geocoder.ip('me')
            lat = g.latlng
            str1 = "latitude position is " + str(lat[0])
            str2 = "longitude position is " + str(lat[1])
            print("Jarvis: ", str1)
            print("Jarvis: ", str2)
            d = str1 + str2
            log_(d)
            say(str1)
            say(str2)
        elif 'bye' in word or 'bye jarvis' in word:
            log_(word)
            break
        log_(res)
        if matched_index == 0:
            if 'open vlc' in word or 'play song' in word:
                #print('processing...')
                #say('processing...')
                global player
                player = vlc_player(word)
            if 'next song' in word or 'pause' in word or 'play' in word or 'stop song' in word or 'close' in word:
                try:
                    player = vlc_player(word, player)
                except:
                    pass
コード例 #29
0
import geocoder

myloc = geocoder.ip('me')
print(myloc.city)
コード例 #30
0
ファイル: Main.py プロジェクト: RyanEder/MavisPy
 def GetLatLng(self, ip_address=None):
     if ip_address:
         return geocoder.ip(ip_address).latlng
     else:
         return geocoder.ip('me').latlng
コード例 #31
0
ファイル: weather.py プロジェクト: PukieDiederik/WeatherApp
import geocoder
import requests
import gui
import os

from dotenv import load_dotenv
load_dotenv()

# %% Call openWeatherMap's onecall api
# exclude should be a string with each section seperated by a comma (no spaces)
def oneCallRequest(apiKey : str, latlng, exclude):
    data = requests.get(f"http://api.openweathermap.org/data/2.5/onecall?lat={latlng[0]}&lon={latlng[1]}&exclude={exclude}&units=metric&appid={apiKey}").json()
    return data

# %% Get data
data = oneCallRequest(os.environ.get("WEATHER_APIKEY"), geocoder.ip("me").latlng, "minutely,alerts")

# %% Start GUI
app = PyQt5.QtWidgets.QApplication([])
app.setStyleSheet(open("./Resources/stylesheets/WeatherApp.css").read())

main = gui.WeatherApp() #initializes everything in the window
main.setWeatherIcon(data["current"]["weather"][0]["icon"])
main.setWeatherName(data["current"]["weather"][0]["description"])
main.setTemperature(data["current"]["temp"],data["current"]["feels_like"])

for i in range(len(data["hourly"])):
    item = data["hourly"][i]
    main.addHOElement(gui.hourlyOverview(main, item["weather"][0]["icon"], item["pop"], item["dt"], item["temp"], item["feels_like"]))

for i in range(len(data["daily"])):
コード例 #32
0
def get_altitude():
    g = geocoder.ip('me')
    gmaps = googlemaps.Client(key='AIzaSyCZXHznz1W3hZSbWqHZXtj6T1euVxyBitk')
    altitudes=gmaps.elevation((g.latlng[0],g.latlng[1]))
    final_altitude = altitudes[0]['elevation']
    return final_altitude
コード例 #33
0
 def getLocation(self):
     '''
     Finds latitude and longitude given user's IP address.
     '''
     return geocoder.ip('me').latlng
コード例 #34
0
ファイル: utils.py プロジェクト: stgleb/energylayer
def get_ip_coordinates(ip):
    g = geocoder.ip(ip)

    return g.lat, g.lng
コード例 #35
0
 def __next__(self):
     mylocation = geocoder.ip('me')
     latlong = mylocation.latlng
     omw = pyowm.OWM('1bfbe76e150ede97d065c9304b1958e0')
     return omw.weather_manager().weather_at_coords(latlong[0],latlong[-1])
コード例 #36
0
ファイル: test.py プロジェクト: ssperling12/follow_the_sun
def latitudelocation():
    g = geocoder.ip('me')
    lat = float(g.lat)
    return lat
コード例 #37
0
#!/usr/bin/env python
import geocoder

g = geocoder.ip('111.65.248.132')

print(g.city)
コード例 #38
0
ファイル: test.py プロジェクト: ssperling12/follow_the_sun
def zipcodelocation():
    g = geocoder.ip('me')
    zp = str(g.postal)
    return zp
コード例 #39
0
def get_lat_long():
    g = geocoder.ip('me')
    print(g.latlng)
コード例 #40
0
import time
import re
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
import geocoder

warnings.filterwarnings('ignore')
global unique_name
unique_name = set()
API_KEY = 'AIzaSyC3O-BdZRrBuOmC_nCvWcbnCdmxEWTztLg'
gmaps = googlemaps.Client(key=API_KEY)
global stop_words
stop_words = set(stopwords.words('english'))
file = 'Data/osm/amenities-vancouver.json.gz'
location = geocoder.ip('me')
loc = location.latlng
# loc = [49.282761666666666, -123.12364166666666]

cuisine_style = [
    'acadian', 'afghan', 'american', 'arab', 'brazilian', 'buddhist',
    'burmese', 'cambodian', 'caribbean', 'chinese', 'cuban', 'czech', 'dutch',
    'ethiopian', 'filipino', 'french', 'german', 'greek', 'hong kong',
    'indian', 'indonesian', 'irish', 'italian', 'jamaican', 'japanese',
    'korean', 'lebanese', 'malaysian', 'malaysian', 'mediterranean', 'mexican',
    'mexican', 'mongolian', 'moroccan', 'persian', 'peruvian', 'portuguese',
    'singaporean', 'taiwanese', 'thai', 'turkish', 'ukranian', 'vietnamese',
    'west_coast'
]

コード例 #41
0
def send_anonymous_stats(start_time, debug=False):
    """
    Send anonymous usage statistics

    Example use:
        current_stat = return_stat_file_dict(csv_file)
        add_update_csv(csv_file, 'stat', current_stat['stat'] + 5)
    """
    if debug:
        logger.setLevel(logging.DEBUG)
    else:
        logger.setLevel(logging.INFO)

    try:
        client = InfluxDBClient(STATS_HOST, STATS_PORT, STATS_USER,
                                STATS_PASSWORD, STATS_DATABASE)
        # Prepare stats before sending
        uptime = (time.time() - start_time) / 86400.0  # Days
        add_update_csv(STATS_CSV, 'uptime', uptime)

        version_num = db_retrieve_table_daemon(AlembicVersion, entry='first')
        version_send = version_num.version_num if version_num else 'None'
        add_update_csv(STATS_CSV, 'alembic_version', version_send)

        outputs = db_retrieve_table_daemon(Output)
        add_update_csv(STATS_CSV, 'num_relays', outputs.count())

        inputs = db_retrieve_table_daemon(Input)
        add_update_csv(STATS_CSV, 'num_sensors', inputs.count())
        add_update_csv(STATS_CSV, 'num_sensors_active',
                       inputs.filter(Input.is_activated.is_(True)).count())

        conditionals = db_retrieve_table_daemon(Conditional)
        add_update_csv(STATS_CSV, 'num_conditionals', conditionals.count())
        add_update_csv(
            STATS_CSV, 'num_conditionals_active',
            conditionals.filter(Conditional.is_activated.is_(True)).count())

        pids = db_retrieve_table_daemon(PID)
        add_update_csv(STATS_CSV, 'num_pids', pids.count())
        add_update_csv(STATS_CSV, 'num_pids_active',
                       pids.filter(PID.is_activated.is_(True)).count())

        triggers = db_retrieve_table_daemon(Trigger)
        add_update_csv(STATS_CSV, 'num_triggers', triggers.count())
        add_update_csv(STATS_CSV, 'num_triggers_active',
                       triggers.filter(Trigger.is_activated.is_(True)).count())

        functions = db_retrieve_table_daemon(CustomController)
        add_update_csv(STATS_CSV, 'num_functions', functions.count())
        add_update_csv(
            STATS_CSV, 'num_functions_active',
            functions.filter(CustomController.is_activated.is_(True)).count())

        actions = db_retrieve_table_daemon(Actions)
        add_update_csv(STATS_CSV, 'num_actions', actions.count())

        methods = db_retrieve_table_daemon(Method)
        add_update_csv(STATS_CSV, 'num_methods', methods.count())
        add_update_csv(
            STATS_CSV, 'num_methods_in_pid',
            pids.filter(PID.setpoint_tracking_type == 'method').count())
        add_update_csv(
            STATS_CSV, 'num_setpoint_meas_in_pid',
            pids.filter(PID.setpoint_tracking_type == 'input-math').count())

        country = geocoder.ip('me').country
        if not country:
            country = 'None'
        add_update_csv(STATS_CSV, 'country', country)
        add_update_csv(
            STATS_CSV, 'ram_use_mb',
            resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / float(1000))

        add_update_csv(STATS_CSV, 'Mycodo_revision', MYCODO_VERSION)
        add_update_csv(
            STATS_CSV, 'master_branch',
            int(os.path.exists(os.path.join(INSTALL_DIRECTORY, '.master'))))

        # Combine stats into list of dictionaries
        new_stats_dict = return_stat_file_dict(STATS_CSV)
        formatted_stat_dict = []
        for each_key, each_value in new_stats_dict.items():
            if each_key != 'stat':  # Do not send header row
                formatted_stat_dict = add_stat_dict(formatted_stat_dict,
                                                    new_stats_dict['id'],
                                                    each_key, each_value)

        # Send stats to secure, remote influxdb server (only write permission)
        client.write_points(formatted_stat_dict)
        logger.debug("Sent anonymous usage statistics")
        return 0
    except requests.ConnectionError:
        logger.debug("Could not send anonymous usage statistics: Connection "
                     "timed out (expected if there's no internet or the "
                     "server is down)")
    except InfluxDBServerError as except_msg:
        logger.error("Statistics: InfluxDB server error: {}".format(
            except_msg['error']))
    except Exception as except_msg:
        logger.exception(
            "Could not send anonymous usage statistics: {err}".format(
                err=except_msg))
    return 1
コード例 #42
0
ファイル: main.py プロジェクト: PatrickCenteno/WeatherFinder
def get_location_values(my_ip):
	g = geocoder.ip(str(my_ip))
	return [g.lat, g.lng, g.city, g.state, g.country]
コード例 #43
0
ファイル: main.py プロジェクト: NMaass/dinefind
def location():
    g = geocoder.ip('me')
    return "{}, {}".format(g.latlng[0], g.latlng[1])
コード例 #44
0
ファイル: weather.py プロジェクト: kyrisu/dotfiles
# -*- coding: utf-8 -*-
import geocoder
import json
import requests

# forecast.io api key:
f = open('/home/christoph/.config/forecast-io-key')
key = f.readline().rstrip()
f.close()

# Get current longitude and latitude based on IP address:
loc = geocoder.ip(requests.get('http://ipinfo.io/ip').text.rstrip())
city = loc.locality

# Get weather info:
root_url = 'https://api.forecast.io/forecast/'
weather = requests.get(root_url + key + '/' + str(loc.lat) + ',' + str(loc.lng))
weather = json.loads(weather.text)

# Convert temperature to Celcius:
temperature = round((weather['currently']['temperature'] - 32) * 5/9)

# Get current weather condition:
condition = weather['currently']['summary']

# Translate city into Irish:
cdict = dict({'Boston': {'irish': 'Bostún'}})

try:
    cathair = cdict[city]['irish']
except KeyError:
コード例 #45
0
ファイル: statistics.py プロジェクト: ldm-top/Mycodo
def send_anonymous_stats(start_time):
    """
    Send anonymous usage statistics

    Example use:
        current_stat = return_stat_file_dict(csv_file)
        add_update_csv(csv_file, 'stat', current_stat['stat'] + 5)
    """
    try:
        client = InfluxDBClient(STATS_HOST, STATS_PORT, STATS_USER,
                                STATS_PASSWORD, STATS_DATABASE)
        # Prepare stats before sending
        uptime = (time.time() - start_time) / 86400.0  # Days
        add_update_csv(STATS_CSV, 'uptime', uptime)

        version_num = db_retrieve_table_daemon(AlembicVersion, entry='first')
        version_send = version_num.version_num if version_num else 'None'
        add_update_csv(STATS_CSV, 'alembic_version', version_send)

        outputs = db_retrieve_table_daemon(Output)
        add_update_csv(STATS_CSV, 'num_relays', get_count(outputs))

        inputs = db_retrieve_table_daemon(Input)
        add_update_csv(STATS_CSV, 'num_sensors', get_count(inputs))
        add_update_csv(STATS_CSV, 'num_sensors_active',
                       get_count(inputs.filter(Input.is_activated == True)))

        conditionals = db_retrieve_table_daemon(Conditional)
        add_update_csv(STATS_CSV, 'num_conditionals', get_count(conditionals))
        add_update_csv(
            STATS_CSV, 'num_conditionals_active',
            get_count(conditionals.filter(Conditional.is_activated == True)))

        pids = db_retrieve_table_daemon(PID)
        add_update_csv(STATS_CSV, 'num_pids', get_count(pids))
        add_update_csv(STATS_CSV, 'num_pids_active',
                       get_count(pids.filter(PID.is_activated == True)))

        lcds = db_retrieve_table_daemon(LCD)
        add_update_csv(STATS_CSV, 'num_lcds', get_count(lcds))
        add_update_csv(STATS_CSV, 'num_lcds_active',
                       get_count(lcds.filter(LCD.is_activated == True)))

        math = db_retrieve_table_daemon(Math)
        add_update_csv(STATS_CSV, 'num_maths', get_count(math))
        add_update_csv(STATS_CSV, 'num_maths_active',
                       get_count(math.filter(Math.is_activated == True)))

        methods = db_retrieve_table_daemon(Method)
        add_update_csv(STATS_CSV, 'num_methods', get_count(methods))
        add_update_csv(STATS_CSV, 'num_methods_in_pid',
                       get_count(pids.filter(PID.method_id != '')))

        timers = db_retrieve_table_daemon(Timer)
        add_update_csv(STATS_CSV, 'num_timers', get_count(timers))
        add_update_csv(STATS_CSV, 'num_timers_active',
                       get_count(timers.filter(Timer.is_activated == True)))

        country = geocoder.ip('me').country
        if not country:
            country = 'None'
        add_update_csv(STATS_CSV, 'country', country)
        add_update_csv(
            STATS_CSV, 'ram_use_mb',
            resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / float(1000))

        add_update_csv(STATS_CSV, 'Mycodo_revision', MYCODO_VERSION)

        # Combine stats into list of dictionaries
        new_stats_dict = return_stat_file_dict(STATS_CSV)
        formatted_stat_dict = []
        for each_key, each_value in new_stats_dict.items():
            if each_key != 'stat':  # Do not send header row
                formatted_stat_dict = add_stat_dict(formatted_stat_dict,
                                                    new_stats_dict['id'],
                                                    each_key, each_value)

        # Send stats to secure, remote influxdb server (only write permission)
        client.write_points(formatted_stat_dict)
        logger.debug("Sent anonymous usage statistics")
        return 0
    except requests.ConnectionError:
        logger.debug("Could not send anonymous usage statistics: Connection "
                     "timed out (expected if there's no internet or the "
                     "server is down)")
    except Exception as except_msg:
        logger.exception(
            "Could not send anonymous usage statistics: {err}".format(
                err=except_msg))
    return 1
コード例 #46
0
ファイル: statistics.py プロジェクト: ciscomonkey/Mycodo
def send_anonymous_stats(start_time):
    """
    Send anonymous usage statistics

    Example use:
        current_stat = return_stat_file_dict(csv_file)
        add_update_csv(csv_file, 'stat', current_stat['stat'] + 5)
    """
    try:
        client = InfluxDBClient(STATS_HOST, STATS_PORT, STATS_USER, STATS_PASSWORD, STATS_DATABASE)
        # Prepare stats before sending
        uptime = (time.time() - start_time) / 86400.0  # Days
        add_update_csv(STATS_CSV, 'uptime', uptime)

        version_num = db_retrieve_table_daemon(
            AlembicVersion, entry='first')
        version_send = version_num.version_num if version_num else 'None'
        add_update_csv(STATS_CSV, 'alembic_version', version_send)

        outputs = db_retrieve_table_daemon(Output)
        add_update_csv(STATS_CSV, 'num_relays', get_count(outputs))

        inputs = db_retrieve_table_daemon(Input)
        add_update_csv(STATS_CSV, 'num_sensors', get_count(inputs))
        add_update_csv(STATS_CSV, 'num_sensors_active',
                       get_count(inputs.filter(Input.is_activated == True)))

        conditionals = db_retrieve_table_daemon(Conditional)
        add_update_csv(STATS_CSV, 'num_conditionals', get_count(conditionals))
        add_update_csv(STATS_CSV, 'num_conditionals_active',
                       get_count(conditionals.filter(Conditional.is_activated == True)))

        pids = db_retrieve_table_daemon(PID)
        add_update_csv(STATS_CSV, 'num_pids', get_count(pids))
        add_update_csv(STATS_CSV, 'num_pids_active',
                       get_count(pids.filter(PID.is_activated == True)))

        lcds = db_retrieve_table_daemon(LCD)
        add_update_csv(STATS_CSV, 'num_lcds', get_count(lcds))
        add_update_csv(STATS_CSV, 'num_lcds_active',
                       get_count(lcds.filter(LCD.is_activated == True)))

        math = db_retrieve_table_daemon(Math)
        add_update_csv(STATS_CSV, 'num_maths', get_count(math))
        add_update_csv(STATS_CSV, 'num_maths_active',
                       get_count(math.filter(Math.is_activated == True)))

        methods = db_retrieve_table_daemon(Method)
        add_update_csv(STATS_CSV, 'num_methods',
                       get_count(methods))
        add_update_csv(STATS_CSV, 'num_methods_in_pid',
                       get_count(pids.filter(PID.method_id != '')))

        country = geocoder.ip('me').country
        if not country:
            country = 'None'
        add_update_csv(STATS_CSV, 'country', country)
        add_update_csv(STATS_CSV, 'ram_use_mb',
                       resource.getrusage(
                           resource.RUSAGE_SELF).ru_maxrss / float(1000))

        add_update_csv(STATS_CSV, 'Mycodo_revision', MYCODO_VERSION)

        # Combine stats into list of dictionaries
        new_stats_dict = return_stat_file_dict(STATS_CSV)
        formatted_stat_dict = []
        for each_key, each_value in new_stats_dict.items():
            if each_key != 'stat':  # Do not send header row
                formatted_stat_dict = add_stat_dict(formatted_stat_dict,
                                                    new_stats_dict['id'],
                                                    each_key,
                                                    each_value)

        # Send stats to secure, remote influxdb server (only write permission)
        client.write_points(formatted_stat_dict)
        logger.debug("Sent anonymous usage statistics")
        return 0
    except requests.ConnectionError:
        logger.debug("Could not send anonymous usage statistics: Connection "
                     "timed out (expected if there's no internet or the "
                     "server is down)")
    except Exception as except_msg:
        logger.exception(
            "Could not send anonymous usage statistics: {err}".format(
                err=except_msg))
    return 1
コード例 #47
0
ファイル: app.py プロジェクト: eunicen1/Barkode
def getLocation():
    g = geocoder.ip('me')
    return str(g.latlng[0]) + "," + str(g.latlng[1]) + ";"
コード例 #48
0
ファイル: test_geocoder.py プロジェクト: donstan/geocoder
def test_ip():
    g = geocoder.ip(ip)
    assert g.ok
コード例 #49
0
ファイル: test.py プロジェクト: ssperling12/follow_the_sun
def longitudelocation():
    g = geocoder.ip('me')
    lng = float(g.lng)
    return lng
コード例 #50
0
ファイル: geoip.3.py プロジェクト: somecat1996/APTDection
    '61.129.7.20', '61.147.122.129', '61.147.234.78', '61.147.234.79',
    '61.155.170.129', '61.155.201.38', '61.155.201.96', '74.208.105.171'
]

with open('webPage/server_map.json') as file:
    geoip = json.load(file)

with open('/usr/local/mad/report/server_map.json', 'w') as file:
    json.dump(geoip, file)

resip = list()
for count, ip in enumerate(ipset[166:]):
    if ipaddress.ip_address(ip).is_private:
        print(count + 167, ip, 'private address')
        continue
    latlng = geocoder.ip(ip).latlng
    # try:
    #     r = requests.get(f'http://ipinfo.io/{ip}?token={TOKEN}')
    #     j = r.json()['loc']
    #     l = j.split(',')
    #     latlng = (float(l[0]), float(l[1]))
    # except requests.exceptions.ConnectionError:
    #     latlng = None
    print(count + 167, ip, latlng)  ###
    if latlng:
        geoip.append(dict(
            name=ip,
            latLng=latlng,
        ))
    if latlng is None:
        resip.append((ip, 0))
コード例 #51
0
def get_location(gmaps):
    ''' Ask user to either input or speak their adress and convert it into lat,lng'''

    while True:
        print("Do you want to input your address by:")
        print("\t1. Speech, or")
        print("\t2. Typing, or")
        print("\t3. Auto detect.")
        time.sleep(1.4)
        choice = input("Your choice (1, 2 or 3): ")
        if choice != '' and choice.isdigit() and (int(choice) in [1,2,3]):
            choice = int(choice)
            break
        else:
            print("\nInput not recognized, please re-enter.")
            
        logging.debug(f"User choice: {choice}")
    
    if choice == 1:
        userAddress = recognize_speech()
        if userAddress != None:
            while True:
                print("Detected Address:")
                print(userAddress)
                answer = input("Is this your address? (y/n)")
                if check_answer(answer):
                    break
                elif not check_answer(answer):
                    answer = input("Retry? (y/n): ")
                    if check_answer(answer):
                        userAddress = recognize_speech()
                    else:
                        while True:    
                            userAddress = input("Enter your Adress: ")
                            if userAddress != '':
                                break
                        print(f"Address: {userAddress}")
        else:
            while True:    
                userAddress = input("Enter your Adress: ")
                if userAddress != '':
                    break
    elif choice == 2:     
        while True:    
            userAddress = input("Enter your Adress: ")
            if userAddress != '':
                break
    elif choice == 3:
        g = geocoder.ip('me')
        userLocation = str(g.latlng[0]) + ',' + str(g.latlng[1])
        temp = gmaps.reverse_geocode(g.latlng)
        userAddress = temp[0]['formatted_address']
        logging.debug(f"Detected user address: {userAddress}, attitude: {userLocation}")
        print(f"We have detected your address: {userAddress}")
        userInput = input("Is this correct? (y/n):")
        if check_answer(userInput):
            return userLocation, userAddress
        else:
            while True:    
                userAddress = input("Enter your Adress: ")
                if userAddress != '':
                    break

    geocodeResult = gmaps.geocode(userAddress)
    if len(geocodeResult) == 0:
        logging.error(f"Unable to recognize user Address: {userAddress}")
        print("Unable to identify address")
        exit()

    attitude = geocodeResult[0]['geometry']['location']
    userLocation = str(attitude['lat']) + ',' + str(attitude['lng'])
    logging.debug(f"Input adress: {userAddress}, attitude: {userLocation}")

    return userLocation, userAddress
コード例 #52
0
def getCity():
    global city
    g = geocoder.ip('me')
    city = g.city
コード例 #53
0
def fillFichaMascota():
    form = UpdateMascotaDesaparecidaForm()
    cur = conn.cursor(buffered=True, dictionary=True)
    query = f"SELECT STATE FROM MASCOTA WHERE ID_MASCOTA={session['id_last_pet']}"
    cur.execute(query)
    estado: int = cur.fetchone()['STATE']
    cur.close()
    ip = 'me'
    try:
        if request.headers.get('X-Real-Ip'):
            ip = request.headers.get('X-Real-Ip')
            print(ip)
    except:
        print('no se consiguio la direccion')
    g = geocoder.ip(ip)
    latitud = g.latlng[0]
    longitud = g.latlng[1]
    if form.validate_on_submit():
        cur = conn.cursor(buffered=True)
        try:
            if estado == 0:
                query = f"SELECT actualiza_mascota({session['id_last_pet']}, '{form.comentario.data}', {form.latitud.data}, {form.longitud.data}, '{form.nombre.data}','{form.fecha.data}',{form.edad.data})"
                cur.execute(query)
                response: bool = cur.fetchone()[0]
            else:
                query = f"SELECT actualiza_mascota({session['id_last_pet']}, '{form.comentario.data}', {form.latitud.data}, {form.longitud.data}, '','{form.fecha.data}',0)"
                cur.execute(query)
                response: bool = cur.fetchone()[0]

            if form.negro.data:
                query = f"SELECT agrega_pelaje({session['id_last_pet']}, 1)"
                cur.execute(query)
            if form.blanco.data:
                query = f"SELECT agrega_pelaje({session['id_last_pet']}, 2)"
                cur.execute(query)
            if form.marron.data:
                query = f"SELECT agrega_pelaje({session['id_last_pet']}, 3)"
                cur.execute(query)
            if form.gris.data:
                query = f"SELECT agrega_pelaje({session['id_last_pet']}, 4)"
                cur.execute(query)
            if form.amarillo.data:
                query = f"SELECT agrega_pelaje({session['id_last_pet']}, 5)"
                cur.execute(query)

            photos = form.photo.raw_data
            for item in photos:
                foto = Image.open(item)
                # Compresion de imagenes antes de guardar en base de datos
                thumb_io = BytesIO()
                foto.save(thumb_io, format='JPEG', quality=20)
                archivo = thumb_io.getvalue()
                query = "SELECT agrega_fotografia(?,?)"
                cur.execute(query, (session['id_last_pet'], archivo))

            if response:
                flash(f'Actualizacion de Información correcta',
                      category='success')
                conn.commit()
                return redirect(
                    url_for('mostrarMascota', id=session['id_last_pet']))
            else:
                flash(f'Algo salio mal intente nuevamente', category='danger')
                return redirect(url_for('loginpage'))
        except mariadb.Error as e:
            print(f'Error en base de datos: {e}')
            flash(f'Error en base de datos', category='danger')
        finally:
            cur.close()
    return render_template('fichaMascota.html',
                           Title='Informacion de Mascota',
                           form=form,
                           estado=estado,
                           latitud=latitud,
                           longitud=longitud)
コード例 #54
0
def loc():
    g = geocoder.ip('me')
    return(g.city)
コード例 #55
0
ファイル: Video.py プロジェクト: surya1304/Final_Year_Project
        '/Users/indukurisuryasaiharischyandraprasad/Desktop/DATASET/Final_Year_Project'
    )

    f = open('face_encodings.pckl', 'wb')
    pickle.dump(known_face_encodings, f)
    f.close()

    f = open('face_names.pckl', 'wb')
    pickle.dump(known_face_names, f)
    f.close()

    print("Success")

if mode == 'display':

    g = geocoder.ip('me')

    location1 = " \nCity: " + str(g.city) + " \nState: " + str(
        g.state) + " \nCountry: " + str(g.country) + " \nPincode: " + str(
            g.postal)

    (lat, long) = getLocation()
    location = "Latitude: " + str(lat) + " Longitude: " + str(long) + location1

    lat_in_deg = math.floor(lat)
    lat_in_min1 = (lat - lat_in_deg) * 60
    lat_in_min = math.floor(lat_in_min1)
    lat_in_sec = round((lat_in_min1 - lat_in_min) * 60, 2)

    long_in_deg = math.floor(long)
    long_in_min1 = (long - long_in_deg) * 60
コード例 #56
0
ファイル: views.py プロジェクト: maya-choudhury/surge-surfer
def index():
    check = 0
    error_msg = " "

    if request.method == "POST":
        if request.form['button'] == 'Submit':

            try:
                earliest = ""
                latest = ""
                start = ""
                end = ""

                first = request.form['datetimepicker3']
                last = request.form['datetimepicker1']

                early = str(dt.date.today()) + " " + first
                earliest = dt.datetime.strptime(
                    early, '%Y-%m-%d %I:%M %p').timestamp()
                late = str(dt.date.today()) + " " + last
                latest = dt.datetime.strptime(late,
                                              '%Y-%m-%d %I:%M %p').timestamp()
                start = request.form['startLocation']
                end = request.form['endLocation']
                recieving_phone_number = request.form['phoneNumber']
                if not start or not end:
                    error_msg = "You must enter your phone number, earliest and latest arrival times, and your start point and final destination."
                    return render_template("index.html",
                                           ret=[],
                                           length=0,
                                           error=error_msg,
                                           early="",
                                           late="")

            except:
                error_msg = "You must enter your phone number, earliest and latest arrival times, and your start point and final destination."
                return render_template("index.html",
                                       ret=[],
                                       length=0,
                                       error=error_msg,
                                       early="",
                                       late="")

            #get current longitude and latitude
            if not start:
                g = geocoder.ip('me')
                curr_loc = g.latlng
                origin_str = str(curr_loc[0]) + "," + str(curr_loc[1])
            else:
                origin_str = start

            #api key
            key = 'AIzaSyDVZ5-R9dw1EFWuzQ8ofHZmqqb4mHiVQfw'

            #url format: url/json?origin=&destination=&arrival=&apikey=

            url = 'https://maps.googleapis.com/maps/api/distancematrix/json?'
            #origin_str = str(curr_loc[0]) + "," + str(curr_loc[1])

            url += 'origins=' + origin_str
            #print(url)

            #destinations = '13813 Saratoga Vista Ave'
            #destinations = '38.953,-77.2295'

            destinations = '+'.join(end.split(' '))  #convert to url format

            url += '&destinations=' + destinations

            #window gives 2 date time objects

            #earliest = early.timestamp()
            #latest = late.timestamp()

            #earliest = datetime.strptime(first, "%I:%M %p")
            #latest = datetime.strptime(last, "%I:%M %p")

            #print(str(datetime.now().year) + " " + str(datetime.now().month) + " " + str(datetime.now().day) + " " + first)

            early_url = url + "&arrival_time=" + str(earliest) + '&key=' + key
            late_url = url + "&arrival_time=" + str(latest) + '&key=' + key

            r = requests.get(early_url)
            print(r.json())
            early_departure_int = earliest - r.json(
            )['rows'][0]['elements'][0]['duration']['value']
            early_departure = time.strftime(
                '%I:%M %p', time.localtime(early_departure_int))

            r = requests.get(late_url)
            late_departure_int = latest - r.json(
            )['rows'][0]['elements'][0]['duration']['value']
            late_departure = time.strftime('%I:%M %p',
                                           time.localtime(late_departure_int))

            early_time = time.localtime(early_departure_int)

            rounded_start = math.ceil(early_departure_int / 900) * 900
            print(rounded_start, late_departure_int)
            tracker = rounded_start
            time_interval = []
            while tracker <= late_departure_int:
                time_interval.append(tracker)
                tracker += 900

            mins_interval = [
                dt.datetime.fromtimestamp(num).minute +
                dt.datetime.fromtimestamp(num).hour * 60
                for num in time_interval
            ]
            mins_interval = np.array(mins_interval)

            day = dt.datetime.fromtimestamp(rounded_start).day

            data = pd.read_csv("data.csv")
            data = data.drop(labels=[
                "Unnamed: 0", "driver_id", "ride_id", "event", "timestamp",
                "ride_distance", "ride_duration", "hour"
            ],
                             axis=1)
            X = data.drop(labels=["ride_prime_time"], axis=1)
            y = data["ride_prime_time"].astype(bool).astype(int)

            model = RandomForestClassifier(class_weight={
                0: 1,
                1: 1.1
            },
                                           min_samples_split=480,
                                           random_state=0)
            model.fit(X, y)

            data2 = data.loc[data["ride_prime_time"] > 0]
            X2 = data2.drop(labels=["ride_prime_time"], axis=1)
            y2 = data2["ride_prime_time"]

            model2 = RandomForestClassifier(class_weight='balanced',
                                            min_samples_leaf=10,
                                            min_samples_split=148,
                                            random_state=0)
            model2.fit(X2, y2)

            def predict(day, intervals):
                y_pred = []
                for interval in intervals:
                    param = np.array([day, interval]).reshape(1, -1)
                    y_pred.append(model.predict(param)[0])
                surge_pred = []
                for i in range(len(intervals)):
                    if y_pred[i]:
                        param = np.array([day, intervals[i]]).reshape(1, -1)
                        surge_pred.append(model2.predict(param)[0])
                    else:
                        surge_pred.append(0)
                return surge_pred

            preds = predict(day, mins_interval)
            print(preds)

            tup_data = list(zip(time_interval, preds))
            tup_data.sort(key=lambda x: (x[1], x[0]))
            print(tup_data)

            try:
                ret = tup_data[0:3]
            except:
                ret = tup_data

            plt.cla()
            plt.clf()
            plt.figure()
            time_list = [
                time.strftime('%I:%M %p', time.localtime(num))
                for num in time_interval
            ]
            sns.set(style="dark", rc={"lines.linewidth": 4.5})
            sns.set_palette("GnBu_d", 3)
            plt.rcParams["font.family"] = "Helvetica"
            # Plot the responses for different events and regions
            ax = sns.lineplot(x=time_list,
                              y=preds)  # edit this line with data and vars
            ax.set_yticks([])
            ax.set(xlabel='Time',
                   ylabel='Surge',
                   title="When should you ride?")
            plt.savefig('static/graph.png')
            ret = [time for time, surge in ret]
            print(ret)
            #ret = [str(dt.datetime.fromtimestamp(num).hour) + ':' + str(dt.datetime.fromtimestamp(num).minute) for num in ret]
            ret = [
                time.strftime('%I:%M %p', time.localtime(num)) for num in ret
            ]
            print(ret)
            try:
                message = client.messages \
                    .create(
                        body= "leave after " + early_departure + " by " + late_departure,
                        from_=sending_phone_number,
                        to=recieving_phone_number
                    )
            except:
                error_msg = "Unable to send text message with details to " + recieving_phone_number
                return render_template("index.html",
                                       ret=[],
                                       length=0,
                                       error=error_msg,
                                       early=early_departure,
                                       late=late_departure)
            return render_template("index.html",
                                   ret=ret,
                                   length=len(ret),
                                   error="",
                                   early=early_departure,
                                   late=late_departure)
            print(message.sid)
        else:
            return render_template("index.html",
                                   ret=[],
                                   length=0,
                                   error="",
                                   early="",
                                   late="")

    return render_template("index.html",
                           ret=[],
                           length=0,
                           error="",
                           early="",
                           late="")
コード例 #57
0
ファイル: daemonutils.py プロジェクト: rmaresky/Mycodo
def send_stats(logger, host, port, user, password, dbname):
    """
    Send anonymous usage statistics

    Example use:
        current_stat = return_stat_file_dict()
        add_update_stat(logger, 'stat', current_stat['stat'] + 5)
    """
    try:
        client = InfluxDBClient(host, port, user, password, dbname)
        # Prepare stats before sending
        with session_scope(MYCODO_DB_PATH) as new_session:
            relays = new_session.query(Relay)
            add_update_stat(logger, 'num_relays', get_count(relays))

            sensors = new_session.query(Sensor)
            add_update_stat(logger, 'num_sensors', get_count(sensors))
            add_update_stat(logger, 'num_sensors_active', get_count(sensors.filter(
                Sensor.activated == True)))

            pids = new_session.query(PID)
            add_update_stat(logger, 'num_pids', get_count(pids))
            add_update_stat(logger, 'num_pids_active', get_count(pids.filter(
                PID.activated == True)))

            lcds = new_session.query(LCD)
            add_update_stat(logger, 'num_lcds', get_count(lcds))
            add_update_stat(logger, 'num_lcds_active', get_count(lcds.filter(
                LCD.activated == True)))

            logs = new_session.query(Log)
            add_update_stat(logger, 'num_logs', get_count(logs))
            add_update_stat(logger, 'num_logs_active', get_count(logs.filter(
                Log.activated == True)))
            
            timers = new_session.query(Timer)
            add_update_stat(logger, 'num_timers', get_count(timers))
            add_update_stat(logger, 'num_timers_active', get_count(timers.filter(
                Timer.activated == True)))

        add_update_stat(logger, 'country', geocoder.ip('me').country)
        add_update_stat(logger, 'ram_use_mb', resource.getrusage(
            resource.RUSAGE_SELF).ru_maxrss / float(1000))
        
        user_count = 0
        admin_count = 0
        with session_scope(USER_DB_PATH) as db_session:
            users = db_session.query(Users).all()
            for each_user in users:
                user_count += 1
                if each_user.user_restriction == 'admin':
                    admin_count += 1
        add_update_stat(logger, 'num_users_admin', admin_count)
        add_update_stat(logger, 'num_users_guest', user_count-admin_count)

        add_update_stat(logger, 'Mycodo_revision', MYCODO_VERSION)

        # Combine stats into list of dictionaries to be pushed to influxdb
        new_stats_dict = return_stat_file_dict()
        formatted_stat_dict = []
        for each_key, each_value in new_stats_dict.iteritems():
            if each_key != 'stat':  # Do not send header row
                formatted_stat_dict = add_stat_dict(formatted_stat_dict,
                                                    new_stats_dict['id'],
                                                    each_key,
                                                    each_value)

        # Send stats to influxdb
        client.write_points(formatted_stat_dict)
        logger.debug("[Daemon] Sent anonymous usage statistics")
        return 0
    except Exception as except_msg:
        logger.warning('[Daemon] Could not send anonymous usage statictics: '
            '{}'.format(except_msg))
        return 1
コード例 #58
0
ファイル: views.py プロジェクト: Elmandouh1/GeoDjango-App
def calcDistanceView(request):
    distance = None
    destination = None
    form = MeasurementForm(request.POST or None)
    geolocator = Photon(user_agent="measurements")

    # Location Coordinates
    g = geocoder.ip('me')
    lat = g.latlng[0]
    lon = g.latlng[1]
    location = geolocator.reverse(f"{lat}, {lon}")
    pointA = [lat, lon]

    # Initial Folium Map
    m = folium.Map(width='100%',
                   height='100%',
                   location=get_center_coordinates(lat, lon))
    # Location Marker
    folium.Marker([lat, lon],
                  tooltip='Click here for more',
                  popup=location,
                  icon=folium.Icon(color='blue', icon='home')).add_to(m)

    if form.is_valid():
        instance = form.save(commit=False)

        # destination coordinates
        destination_ = form.cleaned_data.get('destination')
        destination = geolocator.geocode(destination_)
        d_lat = destination.latitude
        d_lon = destination.longitude
        pointB = (d_lat, d_lon)

        # calc distance
        distance = round(geodesic(pointA, pointB).km, 2)  # calc the distance

        # Destination Marker
        m = folium.Map(width='100%',
                       height='100%',
                       location=get_center_coordinates(lat, lon, d_lat, d_lon),
                       zoom_start=get_zoom(distance))
        # Location Marker
        folium.Marker([lat, lon],
                      tooltip='Click here for more',
                      popup=get_center_coordinates(lat, lon),
                      icon=folium.Icon(color='blue', icon='home')).add_to(m)
        folium.Marker([d_lat, d_lon],
                      tooltip='Click here for more',
                      popup=destination,
                      icon=folium.Icon(color='red', icon='cloud')).add_to(m)

        # Draw a line between location and destination
        line = folium.PolyLine(locations=[pointA, pointB],
                               weight=3,
                               color='blue')
        m.add_child(line)  # Append the Line to the Map

        # Location
        instance.location = location
        # Distance
        instance.distance = distance
        instance.save()
    # Map Representation
    m = m._repr_html_()
    context = {
        'distance': distance,
        'destination': destination,
        'form': form,
        'map': m,
    }
    return render(request, 'measurements/main.html', context)
コード例 #59
0
ファイル: pepper.py プロジェクト: rjcf18/Trabs_Exerc_Univ
    def handle_action(self, text, **kwargs):
        """
        Action handler. Handles a text command responding accordingly.
        """

        # Use lowercase for processing.
        text = text.lower()

        logger.debug("Received text: '%s'", text)

        if any(word in text for word in self.STOP_LISTENING):
            self.speak("As you wish boss. Enjoy your day.")
            sys.exit()
        elif any(word == text for word in self.NAMES):
            self.speak("Yes boss?")
        elif "how are you" in text:
            self.speak("I'm fine, thank you.")
        elif "thank you" in text:
            self.speak("Any time boss.")
        elif any("day" in text for word in self.TIME_COMMANDS):
            self.speak(time.strftime("%x"))
        elif any(word in text for word in self.TIME_COMMANDS):
            self.speak(time.strftime("%X"))
        elif any(word in text for word in self.GREETING) or text=="hi":
            self.speak("Hello boss.")
        elif any(string == text for string in self.SWEAR):
            self.speak("I'm sorry boss, but I was not built to execute such a task.")
        elif "open" in text:
            obj = text.split("open ")[1]

            if obj not in self.OPEN_ACTIONS:
                self.speak("I'm sorry boss, but I'm unable to recognize the open command")
            else:
                if "browser" in obj:
                    self.speak("Opening browser.")
                    webbrowser.open("https://www.google.com/")
                elif "map" in obj:
                    self.speak("Opening maps.")
                    webbrowser.open("https://www.google.com/maps/")
                elif "gmail" in obj:
                    self.speak("Opening gmail.")
                    webbrowser.open("https://mail.google.com/")
                elif "facebook" in obj:
                    self.speak("Opening facebook.")
                    webbrowser.open("https://www.facebook.com/")
                elif "youtube" in obj:
                    self.speak("Opening youtube.")
                    webbrowser.open("https://www.youtube.com/")
                elif "home folder" in obj:
                    self.speak("Opening home folder.")
                    folder = os.path.expanduser("~")
                    os.system('xdg-open "%s"' % folder)
                elif "music" in obj:
                    self.speak("Opening music folder.")
                    folder = os.path.expanduser("~/Music")
                    os.system('xdg-open "%s"' % folder)
                elif "pictures" in obj:
                    self.speak("Opening pictures folder.")
                    folder = os.path.expanduser("~/Pictures")
                    os.system('xdg-open "%s"' % folder)
                elif "videos" in obj:
                    self.speak("Opening videos folder.")
                    folder = os.path.expanduser("~/Videos")
                    os.system('xdg-open "%s"' % folder)
                elif "downloads" in obj:
                    self.speak("Opening downloads folder.")
                    folder = os.path.expanduser("~/Downloads")
                    os.system('xdg-open "%s"' % folder)
                elif "documents" in obj:
                    self.speak("Opening documents folder.")
                    folder = os.path.expanduser("~/Documents")
                    os.system('xdg-open "%s"' % folder)
        elif "search" in text:
            txt_split = text.split(" ")
            if txt_split[0]=="wolfram" and txt_split[1]=="search":
                self.handle_wolframalpha_search(text.split("search ")[1])
            else:
                self.speak("Opening google search.")
                url = "https://www.google.com.tr/search?q={}".format(text.split("search ")[1])
                webbrowser.open(url)
        elif "calculate" in text:
            self.handle_wolframalpha_search(text.split("calculate ")[1])
        elif any(word in text for word in self.WEATHER):
            if ' in ' in text:
                place = text.split(" in ")[1]
                out = data_output(data_organizer(data_fetch(url_builder_city(place))))
                if 'brief' in text:
                    self.speak(out[0])
                elif 'detailed' in text:
                    self.speak(out[1])
                else:
                    self.speak(out[0])
            else:
                IP = ipgetter.myip()
                match = geocoder.ip(IP)
                coords = match.latlng
                data = data_organizer(data_fetch(url_builder_coords(coords[0], coords[1])))
                out = data_output(data)

                if 'brief' in text:
                    self.speak(out[0])
                elif 'detailed' in text:
                    self.speak(out[1])
                else:
                    self.speak(out[0])
        elif "detect" in text or "facial detection" in text:
            if "faces" in text:
                faces = detect_faces()
                if faces == 1:
                    self.speak("I'm detecting "+str(faces)+" face. I stored the frame in the data folder.")
                else:
                    self.speak("I'm detecting "+str(faces)+" faces. I stored the frame in the data folder.")
コード例 #60
0
# Retrieve the names of all astronauts currently in the space station

engine = pyttsx3.init()  ## loads the engine for text to speech

url = "http://api.open-notify.org/astros.json"
response = urllib.request.urlopen(url)
result = json.loads(response.read())
a = open("iss.txt", "w")
a.write("There are currently " + str(result["number"]) +
        " astronauts on the ISS \n")
people = result["people"]
for p in people:
    a.write(p["name"] + "- on board")

g = geocoder.ip("me")
a.write("\n Your current Lat/Long is: " + str(g.latlng))
a.close()
with open('iss.txt') as f:
    for line in f:
        print(line)
        engine.say(line)
        engine.runAndWait()

screen = turtle.Screen()
screen.setup(1280, 720)
screen.setworldcoordinates(-180, -90, 180, 90)
screen.bgpic("map.gif")

screen.register_shape("iss.gif")
iss = turtle.Turtle()