When I run the panel application with panel serve script.py I get the error below on the console
How could eliminate this:
2022-05-23 13:18:56,406 Starting Bokeh server version 2.4.3 (running on Tornado 6.1)
2022-05-23 13:18:56,407 User authentication hooks NOT provided (default user enabled)
2022-05-23 13:18:56,412 Bokeh app running at: http://localhost:5006/memoryLeakPlotly
2022-05-23 13:18:56,412 Starting Bokeh server with process id: 17970
17970
free(): invalid size
Aborted (core dumped)
My actual script is here:
import numpy as np, pandas as pd, os
import datetime as dt
from collections import OrderedDict as odict
import colorcet
from colorcet import cm
from cartopy import crs as ccrs
from bokeh.models import Range1d,LinearAxis
from bokeh.models.renderers import GlyphRenderer
import panel as pn, param
import bokeh
import geopandas as gpd
from shapely.geometry import Polygon, shape
import plotly.express as px
import holoviews as hv, datashader as ds
import geoviews as gv #sorun olusturuyor
from holoviews.operation.datashader import rasterize, shade, spread
from holoviews.util.transform import lon_lat_to_easting_northing
from holoviews.element.tiles import StamenTerrain
from holoviews.element import tiles as hvts
from holoviews.util import Dynamic
from holoviews import dim, opts
from datashader.utils import lnglat_to_meters
import plotly.graph_objects as go
from plotly.subplots import make_subplots
hv.extension('bokeh', logo=False, sizing_mode="stretch_width")
pn.extension(loading_spinner='dots', sizing_mode="stretch_width",throttled=True)
class Town(param.Parameterized):
usecols = ['konum_x','konum_y','hour',"countryOrigin","yabanciMi","Date","assigned_poly","province","distance", "festival_bolgesimi"]
df=pd.read_parquet("data/etkinlikFinalData.parquet")
df.rename(columns={"Lat_of_Visit":"latitude","Lon_of_Visit":"longitude","country":"countryOrigin"},inplace=True)
df["yabanciMi"] = np.where(df.countryOrigin.values=="TUR",0,1)
koordinatDonusum = lon_lat_to_easting_northing(df["longitude"],df["latitude"])
df["konum_x"], df["konum_y"] = koordinatDonusum[0], koordinatDonusum[1]
df["hour"] = df.hour.astype(int)
df = df[usecols]
anadata_max_tarih = df.Date.max().date()
anadata_min_tarih = df.Date.min().date()
# referans datasi
referans=pd.read_parquet("data/referans.parquet")
referans_konumlar = referans.poly_referans.unique().tolist()
# mekanlarin polygonlari
etkinlik_lokasyon = gpd.GeoDataFrame(pd.read_json("data/mekanlar.json",orient="index")).reset_index()
etkinlik_lokasyon["coordinates"] = etkinlik_lokasyon["coordinates"].apply(lambda x: [lon_lat_to_easting_northing(i[1],i[0]) for i in x[0]] )
etkinlik_lokasyon["geometry"] = [Polygon(i) for i in etkinlik_lokasyon["coordinates"].values]
del etkinlik_lokasyon["coordinates"]
etkinlik_lokasyon.rename(columns={"index":"Mekan"}, inplace=True)
# slider icin gerekli. Eger son noktaya gelirse basa donecek.
minDate = pd.to_datetime(df.Date.min()).date()
maxDate = pd.to_datetime(df.Date.max()).date()
# etkinlik listesi
etkinlik_cizelge = pd.read_excel("data/Baskent_Kultur_Yolu_Etkinlikler_160522.xlsx")
etkinlik_cizelge = etkinlik_cizelge.loc[:,["Etkinlik","Mekan","Kategori","Başlangıç tarihi"]]
# ana polygon
townKonumPoly = pd.read_csv("data/konumTownKulturYolu.csv", header=None)
koordinatDonusum = lon_lat_to_easting_northing(townKonumPoly[0].values,townKonumPoly[1].values)
x, y = koordinatDonusum[0], koordinatDonusum[1]
townKonumPoly = hv.Path([{'x': x, 'y': y}]).opts(alpha=0.6, color='white',line_width=2)
#widget elemanlari. Genelde param kullanildi ama bazi ozel widgetlar eklendi.
cmaps = ['fire','bgy','bgyw','bmy','gray','kbc']
maps = ['EsriImagery', 'EsriUSATopo', 'EsriTerrain', 'CartoMidnight', 'StamenWatercolor', 'StamenTonerBackground']
bases = odict([(name, name) for name in maps])
gopts = hv.opts.Tiles(responsive=True, xaxis=None, yaxis=None, bgcolor='black', show_grid=False)
alpha = param.Magnitude(default=0.75, doc="Alpha value for the map opacity", label="Harita Saydamlığı")
cmap = param.ObjectSelector(colorcet.palette['fire'], objects={c:colorcet.palette[c] for c in cmaps},label="Nokta Renklendirmesi")
hour = param.Range(default=(0, 24), bounds=(0, 24),label="Saat Aralığı")
basemap = param.Selector(bases, label="Harita Altlığı")
data_opacity = param.Magnitude(1.00,label="Nokta Saydamlığı")
polygon_opacity = param.Magnitude(0.40,label="Mekan Saydamligi")
polygon_visible = param.Boolean(True,label="Mekanlar Gosterilsin mi")
residents_visible = param.Boolean(True,label="Etkinlik Alanında Oturanlar")
#metrik = param.ObjectSelector(default="Cihaz Sayısı", objects=["Sinyal Sayısı", "Cihaz Sayısı"], label = "Sayım Şekli")
date_slider = pn.widgets.DateSlider(name='Tarih',
start = minDate,
end = maxDate,
value = minDate,visible=False)
#simulation = pn.widgets.Toggle(name='Baslat', value=False, button_type='primary')
simulation = pn.widgets.ToggleGroup(name='ToggleGroup', options=['Tüm Kayitlar', 'İlerle', 'Durdur'], behavior="radio")
simulation_time = param.Integer(5, bounds=(3, 12),label="Simulasyon Süresi")
referansBolgeler = pn.widgets.MultiChoice(name='Referans Bölgeler', value = referans_konumlar, options = referans_konumlar)
etkinlik_cizelge = pn.widgets.DataFrame(etkinlik_cizelge,height=500)
def __init__(self, **params):
super(, self).__init__(**params)
self.simulation.param.watch(self.toggle_periodic_callback, 'value')
self.periodic_sim = pn.state.add_periodic_callback(self.simulation_run, period=self.simulation_time * 1000, start=False)
self.point_minx = self.df.konum_x.min() - 10
self.point_maxx = self.df.konum_x.max() + 10
self.point_miny = self.df.konum_y.min() - 300
self.point_maxy = self.df.konum_y.max() + 300
def simulation_run(self):
eskiDeger = self.date_slider.value
if eskiDeger == self.anadata_max_tarih:
setDeger = self.anadata_min_tarih
else:
setDeger = eskiDeger + dt.timedelta(days=1)
self.date_slider.value = setDeger
@param.depends('alpha', 'basemap')
def tiles(self):
map = getattr(hvts, self.basemap)().relabel(self.basemap)
return map.opts(self.gopts).opts(alpha=self.alpha)
@param.depends('hour','simulation.value',"date_slider.value","residents_visible")
def points(self):
if self.residents_visible:
data = self.df.copy()
else:
data = self.df.query("festival_bolgesimi==0")
point = hv.Points(data, kdims=['konum_x', 'konum_y'], vdims=['hour',"Date","festival_bolgesimi"])
if self.hour != (0, 24): point = point.select(hour=self.hour)
if self.simulation.value != 'Tüm Kayitlar':
point = point.select(Date=self.date_slider.value)
return point
def toggle_periodic_callback(self,event):
if event.new in ["İlerle"]:
self.periodic_sim.start()
self.date_slider.visible = True
#['Tüm Kayitlar', 'İlerle', 'Durdur']
elif event.new in ["Durdur"]:
self.periodic_sim.stop()
else:
self.periodic_sim.stop()
self.date_slider.visible = False
@param.depends('polygon_visible','polygon_opacity')
def polygon_create(self):
mekanpolygonlari = gv.Polygons(self.etkinlik_lokasyon, vdims='Mekan',crs=ccrs.epsg(3857)).opts(tools=['hover'],
alpha= self.polygon_opacity if self.polygon_visible else 0, color='Mekan')
return mekanpolygonlari
def viewable(self):
rasterized = rasterize(hv.DynamicMap(self.points), aggregator= getattr(ds,"count")("konum_x"))
shaded = shade(rasterized, cmap=self.param.cmap)
dataplot = shaded.apply.opts(alpha=self.param.data_opacity, show_legend=False)
return hv.DynamicMap(self.tiles).redim(x="x_1").redim.label(y="y"). \
redim.range(x=( self.point_minx, self.point_maxx ),
y=(self.point_miny, self.point_maxy)) * \
dataplot * self.townKonumPoly * gv.DynamicMap(self.polygon_create)
def apply_formatter(self, plot, element):
"""
Cift eksen icin gerekli.
Hook...
"""
p = plot.state
p.extra_y_ranges = {"twiny": Range1d(start=self.min_deger_ref * 0.9, end=self.max_deger_ref * 1.1)}
p.add_layout(LinearAxis(y_range_name="twiny"), 'right')
glyph = p.select(dict(type=GlyphRenderer))[0]
glyph.y_range_name = 'twiny'
@param.depends("date_slider.value")
def line_date(self):
return hv.VLine(self.date_slider.value)
@param.depends("hour","referansBolgeler.value")
def data_create_referans(self):
aralik = range(*[int(i) for i in list(self.hour)])
ozet_dataref = self.referans.loc[(self.referans.hour.isin(aralik)) &
(self.referans.poly_referans.isin(self.referansBolgeler.value))] \
.groupby("Date",as_index=False)["signal_count"].sum()
self.max_deger_ref = ozet_dataref.signal_count.max()
self.min_deger_ref = ozet_dataref.signal_count.min()
return ozet_dataref
@param.depends('hour')
def data_create_etkinlik_ozet(self):
aralik = range(*list(np.round(self.hour).astype(int)))
if not(self.residents_visible):
ozet_etkinlik = self.df.query("festival_bolgesimi==False")
else:
ozet_etkinlik = self.df.copy()
ozet_etkinlik = ozet_etkinlik.loc[self.df.hour.isin(aralik)] \
.groupby("Date",as_index=False)["konum_x"].count() \
.rename(columns={"konum_x":"signal_count"})
self.min_deger = ozet_etkinlik.signal_count.min()
self.max_deger = ozet_etkinlik.signal_count.max()
return ozet_etkinlik
def create_sum_ref_graph(self):
ozet_dataref = self.data_create_referans()
ozet_etkinlik = self.data_create_etkinlik_ozet()
fig = make_subplots(specs=[[{"secondary_y": True}]])
# Add traces
fig.add_trace(
go.Scatter(x = ozet_dataref.Date.values, y = ozet_dataref.signal_count.values, name="Referans"),
secondary_y=False,
)
fig.add_trace(
go.Scatter(x = ozet_etkinlik.Date.values, y = ozet_etkinlik.signal_count.values, name="Etkinlik"),
secondary_y=True,
)
fig.update_xaxes(title_text="Tarih")
fig.update_yaxes(title_text="<b>Etkinlik</b> Sinyal Sayısı", secondary_y=False)
fig.update_yaxes(title_text="<b>Referans</b> Sinyal Sayısı", secondary_y=True)
#fig.update_layout(displayModeBar = False)
return fig
@param.depends('hour','residents_visible','simulation.value','date_slider.value')
def polygon_count_view(self):
hourParam = range(*[int(i) for i in list(self.hour)])
if self.residents_visible:
filtre_resident = [0,1]
else:
filtre_resident = [0]
if self.simulation.value == "Tüm Kayitlar":
filtre_date = np.array([True] * self.df.shape[0])
else:
filtre_date = np.where(self.df.Date.values.astype("datetime64[D]")==self.date_slider.value,True,False)
temp = self.df.loc[filtre_date] \
.query("assigned_poly!=''") \
.query("festival_bolgesimi in @filtre_resident") \
.query("hour in @hourParam") \
.groupby("assigned_poly",as_index=False) \
.agg(countKayit=("yabanciMi","count")).sort_values("countKayit",ascending=False) \
.rename(columns={"assigned_poly":"Mekan","countKayit":"Sinyal Sayisi"})
return px.bar(temp, x = "Mekan", y = "Sinyal Sayisi")
@param.depends('hour','simulation.value','date_slider.value')
def nationality_count_view(self):
hourParam = range(*[int(i) for i in list(self.hour)])
if self.simulation.value == "Tüm Kayitlar":
filtre_date = np.array([True] * self.df.shape[0])
else:
filtre_date = np.where(self.df.Date.values.astype("datetime64[D]")==self.date_slider.value,True,False)
temp = self.df.loc[(~self.df.countryOrigin.isna()) & (filtre_date)].query("hour in @hourParam") \
.groupby("countryOrigin",as_index=False) \
.agg(countKayit=("yabanciMi","count")).sort_values("countKayit",ascending=False).query("countryOrigin!='TUR'").iloc[0:10] \
.rename(columns={"countryOrigin":"Ülke","countKayit":"Sinyal Sayısı"})
return px.bar(temp, x = "Ülke", y = "Sinyal Sayısı")
@param.depends('residents_visible','hour','simulation.value','date_slider.value')
def distance_count_view(self):
## burada ayni kullanici 2 kere sayilmamali. combodan etkilenmeyecek
hourParam = range(*[int(i) for i in list(self.hour)])
if self.residents_visible:
filtre = [0,1]
else:
filtre = [0]
if self.simulation.value == "Tüm Kayitlar":
filtre_date = np.array([True] * self.df.shape[0])
else:
filtre_date = np.where(self.df.Date.values.astype("datetime64[D]")==self.date_slider.value,True,False)
temp = self.df.loc[filtre_date].query("distance<0.5").query("festival_bolgesimi in @filtre") \
.query("hour in @hourParam") \
.rename(columns={"distance":"Mesafe"})
frequencies, bins = np.histogram(temp["Mesafe"], 100)
bins = 0.5 * (bins[:-1] + bins[1:])
return px.bar(x=bins, y=frequencies, labels={'x':'Mesafe', 'y':'Sinyal Sayısı'})
def run():
gspec = pn.GridSpec(height=60,sizing_mode='stretch_width',margin=(0,0,30,0))
townYolu = Town(name="")
#s=pn.Row(pn.Column(townYolu.param), townYolu.viewable)
gspec[0, 0:3 ] = townYolu.simulation
gspec[1, 0:3 ] = townYolu.date_slider
plot = pn.template.MaterialTemplate(site="Festivaller",
title="Mobil Data Sonuçları",
sidebar = [pn.WidgetBox('## Harita Parametreleri',pn.Column(townYolu.param),townYolu.referansBolgeler)],
main=["Veri 5 gün gecikme ile sisteme yansıtılmaktadır. Bu ekran üzerinden **Ankara ve İstanbul Festivalleri** takip edilmektedir.",
pn.Column(pn.Row(
pn.Column(
pn.panel(townYolu.viewable().opts(responsive=True), width=599,height=500),
pn.Row(gspec)),
pn.Tabs(('Referans Karsılaştırma' , pn.panel(townYolu.create_sum_ref_graph,sizing_mode="stretch_both",margin=(0,25,0,20))),
('Etkinlik Listesi', townYolu.etkinlik_cizelge )) ),
pn.Row(townYolu.nationality_count_view,townYolu.distance_count_view),
pn.Row(townYolu.polygon_count_view) )])
plot.sidebar[0].sizing_mode = "stretch_width"
print(os.getpid())
return plot
run().servable()