"Parsed text" is een vooraf gedefinieerde eigenschap. Deze eigenschap is van te voren gedefinieerd (ook bekend als een speciale eigenschap) en komt met extra beheersprivileges, maar kan worden gebruikt net als elk andere door de gebruiker gedefinieerde eigenschap.
H
De gefaalde stofzuigers die men nog zou kunnen repareren maar de reparatie niet door kon gaan gezien er wisselstukken, handleidingen en/of beschikbaarheid van een 3D printer,… ontbraken en die nog niet “oud” zijn, zijn gemiste kansen. Door enkele systeemverbeteringen door te voeren, waar een stad in kan helpen (bijvoorbeeld door te investeren in een 3D printer of andere reparatiemiddelen, opleidingen voor vrijwilligers te organiseren,…) zouden deze wel gerepareerd kunnen worden. De data kan de stad tevens helpen bij het evalueren van zo’n investeringsbeslissing. Ze geeft immers inzage in de specifieke barrière. Als men tevens ook weet welke onderdelen geprint zouden kunnen worden, of gemaakt doordat een hulsel, dopje,… zou kunnen geprint worden, weet men dus hoeveel reparaties toch succesvol zouden kunnen doorgaan en dus hoeveel CO2 hiermee zou kunnen uitgespaard worden. +
Hoe kies ik het juiste netwerk?
Volgende criteria zijn o.a. bepalend in deze keuze:
batterijduur
data grootte
traffic (one-way/two-way)
connectiviteit
Er bestaat daarom een trade-off tussen o.a. volgende netwerken:
NB-IOT
LoRaWAN
Sigfox
test onderwerp
test discussie -- Maarten1 ( overleg ) 26 mei 2021 17:49 (CEST)
captions/weblinks aan images ?
kunnen we weblinks toevoegen aan de images ? en als caption onder de image toevoegen +
(Deze richtlijnen worden momenteel opgemaakt in een co-creatie proces. Aanbeveling dus onder voorbehoud. Deze worden momenteel geregeld geüpdatet. Naar het einde van 2021 toe worden deze richtlijnen gefinaliseerd)
Criteria/aspecten voor keuze datacommunicatie en logging
frequentie datatransmissie , (remote) aanpasbaarheid van frequentie
realtime voor bepaalde toepassingen: vb. overstromingen, RWZI, overstorten
uurlijkse of dagelijkse data doorsturen: vb. droogte-monitoring
optimalisatie door dynamische aanpassing van meetfrequentie of zendfrequentie (vb. overschrijding van grenswaarde, bij een specifiek event of alarm)
energieverbruik en autonomie : Hoe lang kan de device data verzenden met een bepaalde frequentie en met de voorziene energiebron? Is een batterij voldoende of is het nodig om een extra zonnepaneel te voorzien?
data logging : opslagcapaciteit
datacommunicatie technologie
zie extra info
dekking (coverage) voor communicatie/transmissie: te controleren voor de beoogde locaties
geschiktheid voor beoogde toepassing:
outdoor of indoor?
open ruimte of tussen bebouwing?
bovengronds of ondergronds ?
→ mogelijks extra lokale gateways nodig voor indoor/ondergronds/dichte bebouwing
type van remote communicatie/interactie (service): one-way / two-way
dimensies en gewicht (i.f.v. installatie en bevestiging)
vochtbestendigheid (IP normering) → afhankelijk van de locatie of de condities bv. overstromingsbestendigheid
on-site uitlezing van de data (indien gewenst nodig)
geschikte connector voor aansluiting van gewenste/beoogde sensor en compatibiliteit met beoogde sensor
Hierbij is een afweging van criteria/vereisten t.o.v. budget (aankoop + telecom kosten + nodige IT infrastructuur) belangrijk!
In de overleg pagina kunnen ervaringen m.b.t. de verschillende netwerken gedeeld worden (NB-Iot, LoRaWAN, Sigfox).
(Deze richtlijnen worden momenteel opgemaakt in een co-creatie proces. Aanbeveling dus onder voorbehoud. Deze worden momenteel geregeld geüpdatet. Naar het einde van 2021 toe worden deze richtlijnen gefinaliseerd)
Voor het kiezen van een geschikte sensor zien we 2 subvragen:
Hoe kies ik een geschikte sensor voor meten van parameter X?
Kan de sensor deze parameter meten?
Meetprincipe
Sommige parameters kunnen op verschillende wijze (meettechniek) gemeten worden.
Meetprincipes vergelijken: voor-/nadelen, meer/minder geschikt voor bepaalde condities/omstandigheden.
Vb. meting van het waterpeil : hydrostatische meting (druk), ultrasone meting (echo sounding), laser, radar, optisch,…
Meetbereik (range): van… tot…
Resolutie (resolution): kleinste stap/eenheid van die gedetecteerd kan worden
Soms varieert de resolutie over het meetbereik.
Aantal decimalen is niet noodzakelijk gelijk aan resolutie, vb. meting in m met 3 decimalen, maar resolutie is 2mm.
Nauwkeurigheid (accuracy): meetfout, afwijking t.o.v. werkelijke waarde
Nauwkeurigheid kan absoluut of relatief (% tov de meetwaarde) uitgedrukt worden.
vb. nauwkeurigheid 1cm of nauwkeurigheid +/- 0.1% van de meetwaarde
Geïntegreerde correcties
Vb. temperatuur correct voor parameters die temperatuurgevoelig zijn.
Vb. luchtdrukcompensatie bij hydrostatische waterpeilmeting.
Combinatie van een aantal parameters op eenzelfde sensor
Hoe kies ik een geschikte sensor voor de beoogde toepassing?
Parameter(s)
Meetprincipe
Meetbereik, resolutie, nauwkeurigheid
Geïntegreerde correcties
Meetfrequentie en (remote) aanpasbaarheid van meetfrequentie
Kabellengte : indien van toepassing bv. voor ophanging, datacommunicatie, luchtdrukcompensatie, …
Toegelaten waterdruk : hoe diep mag de sensor onder water hangen
Bestendigheid tegen droogval : indien van toepassing voor beoogde meetlocaties
Bestendigheid tegen vorst : indien van toepassing voor beoogde meetlocaties
Bestendigheid tegen vandalisme : indien van toepassing voor beoogde meetlocaties
Algemene robuustheid :beperkt onderhoud en kalibratie
Energieverbruik en autonomie : hoe lang kan de sensor meten met een bepaalde frequentie met de voorziene energiebron: is een batterij voldoende of extra zonnepaneel te voorzien?
Dimensies en gewicht (i.f.v. installatie en ophanging)
On-site uitlezing van de metingen (indien gewenst/nodig)
Waterdichtheid bij hogere waterdruk (diepte in waterkolom)
Modulair systeem : is er uitbreiding mogelijk, bv. extra parameters.
Hierbij is een afweging van criteria/vereisten ten opzichte van budget (aankoop + installatie + onderhoud) belangrijk.
Onderhoud en levensduur van sensoren
Onderhoud en kosten/inspanningen voor onderhoud
Het onderhoud van sensoren heeft een kostprijs die veelal uit het oog wordt verloren.
Sensoren, die geen of slechte metingen geven omdat ze niet onderhouden worden, zijn een verloren investering.
Onderhoudsintensiteit en gevoeligheid van sensor voor vervuiling wordt vooral bepaald door het type parameter (en bijhorend meetprincipe) en de matrix waarin je meet. Bijvoorbeeld, metingen in zoutwater of afvalwater vereisen vaak meer onderhoud. Het type water waarin je meet (afvalwater vs. drinkwater) is daarom bepalend voor de keuze sensor.
Kosten/inspanningen van onderhoud zijn situatiespecifiek waardoor het moeilijk is om een algemene raming te maken.
Belangrijke factoren in onderhoudskost zijn o.a.:
verplaatsing (tijd en afstand) om sensoren te gaan onderhouden
toegankelijkheid van de locatie
vereiste onderhoudsfrequentie (sensor/parameter/locatie afhankelijk)
intensiteit/omvang van onderhoudshandelingen (sensor/parameter/locatie afhankelijk)
Levensduur van de sensor en beschikbaarheid van reserve onderdelen
Er kan een onderscheid gemaakt worden tussen:
type ‘wegwerp sensoren’ met een, door de frabrikant, opgegeven gebruikstermijn, bv. 6 maanden en dan vervangen
type ‘compacte, relatief goedkope sensoren’ waarbij herstellen van een defect vaak niet de moeite is t.o.v. vervanging door een nieuwe sensor. Zonder defect kunnen dergelijke sensoren meerdere jaren worden gebruikt.
type ‘multi-parameter sensoren’ waarbij sommige onderdelen een beperkte levensduur hebben en waarvoor vervangstukken beschikbaar zijn bij de fabrikant
vervangen van sommige onderdelen is te beschouwen als een onderhoudskost, bv. vervangen van membranen of sensortippen
de sensor zelf (met name de elektronica) kan vele jaren gebruikt worden
Hoe kies ik een geschikte sensor ?
Samengevat kan gesteld worden dat om een geschikte sensor te kiezen aandacht gegeven moet worden aan volgende:
goed informeren over technische specificaties en het meetprincipe van de sensor
informeren naar ervaringen, testen, reviews of feedback
expliciet voordelen en nadelen vragen aan fabrikant/verkoper
hoe beter je de condities van de toepassing kent en kan specifiëren, hoe beter de keuze afgestemd is op de toepassing
indien je een breed inzetbare sensor wenst, zullen criteria/afwegingen anders zijn
Hoe kunnen we repair cafés en herstel in het algemeen ondersteunen en zo de kans op succesvol herstel vergroten? +
Repair cafés worden al recurrent georganiseerd op verschillende plaatsen in Vlaanderen en daarbuiten. De verwachtingen en wensen van deelnemende partijen tonen aan welke zaken belangrijk zijn bij het organiseren van repair cafés:
Stakeholder
De droom van de organisatie
Repairgroep
Een transparante omgeving waar alle informatie die nodig is om de beste oplossing te vinden, beschikbaar is;
Ervaringen en resultaten worden maximaal gedeeld binnen een lerend netwerk;
Huidige belemmeringen van herstel weggewerkt, zodat herstellen bijvoorbeeld makkelijk wordt;
Wisselstukken kunnen en mogen geoogst worden uit kapotte toestellen.
méér herstelcultuur.
Repair netwerk
Er bestaat een Google voor herstel waar je het type, merk en model ingeeft. Deze search levert je handleidingen, video’s (met index) en andere vormen van hulp op;
De tool maakt tevens automatisch vertalingen en is in staat onbetrouwbare van kwalitatieve informatie te onderscheiden.
IT
Alle hersteldata worden geborgen in 1 overkoepelend data model, met 1 API;Het platform vraagt data op, op zo’n manier dat het weinig extra inspanningen vraagt van de gebruiker;Lijsten van merken, model- en serienummers worden publiek beschikbaar gemaakt.
Lokale overheden
Beleidsvoorbereidend: Lokale beleidsmakers kunnende benchmark goed in kaart brengen (“nulmeting”) mbv solide data en weten zo beterwaarop in te zetten (beleidsperspectief).
Beleidsopvolgend: men heeft real time data beschikbaar waarmee de effectiviteit van een beleidsmaatregel continu wordt opgevolgd;
Link met klimaat: hiermee de bijdrage van reparatie aan klimaatdoelstellingen te meten.
De Kringwinkel
Laagdrempelige informatie waarmee iedereen aan de slag kan;
Gegevens worden maximaal gedeeld;
Kringwinkel medewerkers leveren goede aanvullende diensten aan commerciële herstellers (bv identificatie).
De professionele hersteller
Vlotte match making hersteller met het defect toestel; Doordat we weten welke herstellers/vrijwilligers welke vaardigheden hebben en zo gericht kunnen doorverwijzen; Herstel is betaalbaar eveneens geholpen door een goede matchmaking waarbij de buiten garantie herstellingen gericht doorverwezen kunnen worden. Opdeze manier wordt de identificatie door ons gedaan, wat een hulp is voor de vrijwillige hersteller of de burger (DIY repair);
Onderzoek – data technisch
Data delen is zeer laagdrempelig en makkelijk;
Beschikbaarheid van de data bv. Herstelvideo’s is gegarandeerd in de tijd.
ABB
Kennis wordt gedeeld met de kleinste gemeentes in VL. Geen uitsluitend grootstedelijk verhaal;
gebruik van een VLOCA genormeerde data architectuur.
Onderzoek - CE
Er bestaan productpaspoorten die uitgebreide informatie-uitwisseling zoals materiaalsamenstelling, reparatie tips & logboeken toelaten.
De data kan ook gebruikt worden om voor een gebied (stad, regio, land, continent) beleidsindicatoren voor de circulaire economie te voeden.
Er bestaan algoritmes die model specifieke identificatie kunnen doen aan de hand van een foto van het label (in ontwikkeling).
productpaspoort
Er is een model specifiek beslissingssysteem opgesteld dat op basis van leeftijd en herstelgeschiedenis correcte indicatie geeft van te verwachten faling, wisselstukken, kost, etc.
Hoe kunnen we repair cafés, en herstel in het algemeen, ondersteunen en zo de kans op succesvol herstel vergroten +
Hoe kunnen we repair cafés, en herstel in het algemeen, ondersteunen en zo de kans op succesvol herstel vergroten? +
Hoe maak ik zelf een databank aan voor mijn citizen science project
Introductie
In deze tutorial zullen we een postgres-database opzetten, gehost in de cloud via Heroku. We ontwerpen het databasemodel in dbdiagram.io en behandelen de import van gegevens uit een Excel-bestand met behulp van Python en SQLAlchemy.
Installatie
Enige voorbereiding is nodig!
Conda-omgeving
We moeten eerst een Python-omgeving opzetten in Conda. Voor deze tutorial gebruiken we Python 3.8. Pakketten kunnen via de commandline worden geïnstalleerd met behulp van:
conda install --file requirements.txt
de requirements.txt file is hier te downloaden.
Registreer je hier voor een Heroku-account: https://signup.heroku.com/
Helaas biedt Heroku vanaf eind November 2022 geen gratis credits meer aan:
Na registratie kan je je eerste app aanmaken:
Kies de naam van de app en je regio, klik op "Create app":
Postgres in de cloud via Heroku
Ga naar "resources" en selecteer "Heroku Postgres".Kies voor "Hobby-Dev":
Klik je net aangemaakte service aan, ga naar de "Settings" om de databank credentials te raadplegen. Je zal deze nodig hebben om te kunnen connecteren naar je databank:
Connectie naar je nieuwe databank
Er zijn verschillende manier om te connecteren naar de database.
Heroku CLI
Ga naar https://devcenter.heroku.com/articles/heroku-cli en volg daar het stappenplan om de Heroku CLI op te zetten in je commandline terminal.
Voor deze tutorial zullen we echter dbeaver gebruiken, dat iets gebruiksvriendelijker is.
Dbeaver
DBeaver is een gratis multi-platform databank tool voor ontwikkelaars, databasebeheerders, analisten en iedereen die met databases moet werken. Het ondersteunt alle populaire databases, inclusief degene die we in deze tutorial zullen gebruiken.
Om DBeaver te gebruiken, moet je al een versie van Postgres op je lokale machine geïnstalleerd hebben: https://www.postgresql.org/download/
Ga naar https://dbeaver.io/ om DBeaver te downloaden.
Open DBeaver nadat het geïnstalleerd is. Je kunt op het pictogram "new database connection" linksboven klikken om een verbinding te maken met de Heroku-database:
Onze databank bevat momenteel nog geen tabellen, maar daar zorgen we voor in de volgende stap.
Databank model
Maak je databank model aan
We zullen gebruik maken van dbdiagram.io om het databank model aan te maken. Eens ontworpen, kan deze geëxporteerd worden naar SQL code. Deze code kunnen we dan uitvoeren in dbeaver om de tabellen en alle relaties tussen de tabellen aan te maken.
In dit voorbeeld maken we 3 tabellen aan. Ze laten ons toe de meetwaarden van de sensoren op te slaan, alsook de meta-data en informatie over de locatie van de sensor.
Eens de tabellen aangemaakt zijn in dbdiagram.io klik je op "export to PostgreSQL". Dit maakt een .sql file aan die we in de volgende stap zullen gebruiken.
Maak de tabellen aan in dbeaver
Je zou de SQL-query kunnen starten met behulp van de Heroku CLI, een Python-script,... maar voor deze tutorial zullen we deze starten vanuit DBeaver.
Open DBeaver en maak verbinding met de database.
Open een nieuw script en plak hierin het .sql-bestand dat we hebben aangemaakt in dbdiagram.io.
Voer dit script uit (ook hier te downloaden: 10-create-tables.sql )
De tabellen zijn nu aangemaakt. Je kan ze bekijken door op "public scheme" te klikken en vervolgens op "ER Diagram":
Migreer je datasheets naar de databank
Voorbeeld csv file
Met de databank en (lege) tabellen op hun plaats is het tijd om te kijken naar het voorbeeld Excel-bestand, te vinden hier , dat we willen importeren.
Er zijn 3 tabbladen in het Excel-bestand:
Locaties, waar wat extra informatie staat over de locaties waar de sensoren zijn geplaatst.
Sensoren, een oplijsting van de verschillende sensoren.
Metingen, een oplijsting van de gegevens die door de sensoren zijn verzameld.
De afbeeldingen hieronder tonen de dummygegevens die in elk van de tabbladen zijn ingevoerd. Deze gegevens zullen we in onze databank uploaden:
Locaties Metingen
Sensoren
Python en SQLalchemy
We zullen Python in combinatie met het SQLalchemy-pakket gebruiken om de gegevens in de Excel-sheets naar de database over te zetten. De volgende scripts (die hier terug te vinden zijn) zijn hiervoor gemaakt:
excel_parser.py : een parser om de Excel-tabbladen in te lezen en te transformeren, zodanig dat ze klaar zijn om in het databank model te plaatsen.
orm.py : bevat de SQLalchemy Object-Relational Mapping (ORM), zodat we gemakkelijk met onze databasestructuur kunnen werken in Python.
push-data-db.py : start dit bestand om de gegevens te lezen, te transformeren en in de databank te plaatsen!
Opmerking: je zal de credentials in "push-data-db.py" moeten aanpassen, zodat ze matchen op jouw database gegevens.
DBASE = 'd2hto0sg05etiq'
USER = 'itwgxojqwqnqwl'
PASSWORD = ';-)'
HOST = 'ec2-34-248-169-69.eu-west-1.compute.amazonaws.com'
PORT = 5432
SCHEMA = 'public'
Nu maken we de connectie met de Heroku hosted postgres databank: de dbclass kan je vinden in dbutils.py . Het laat ons toe om vanuit python aan de slag te gaan met onze postgres databank:
# Database connection for queries
#---------------------------------
# get instance of class
db = dbclass(dbase=DBASE,
user=USER,
password=PASSWORD,
port=PORT,
host=HOST)
# test connection
concheck = db.connected()
print(concheck)
volgende stap, het importeren van de data in de excel sheets:
sensors,measurements,locations = import_excel_data()
Vervolgens pushen we de data naar de databank:
add_locations(db, data=locations)
add_sensors(db, data=sensors)
add_measurements(db, data=measurements)
Het is belangrijk deze bovenstaande 3 lijntjes in de juiste volgorde uit te voeren, daar je eerst de locatie data nodig hebt om ernaar te kunnen refereren in de sensor tabel.
Hieronder zoomen we in op de add_locations functie:
In sessionmaker maken we een handle om te kunnen connecteren naar de heroku gehoste database.
Vervolgens itereren we over elke rij in data , waar we de locatie data kunnen vinden:
...
for index, item in data.iterrows():
...
Vervolgens checken we of de locaties al werden toegevoed in de databank (om duplicates te voorkomen):
...
exists = session.query(sqlalchemy.exists().where(orm_file.Location.name == item['locatie'])).scalar()
...
Als de data nog niet werd toegevoegd, maken we een Location instance aan via de orm_file , en hieraan voegen we de nodige variabelen toe ('locatie','beschrijving','x','y','z'):
...
location_to_add = orm_file.Location()
location_to_add.name = item['locatie']
location_to_add.description = item['beschrijving']
location_to_add.x = item['x']
location_to_add.y = item['y']
location_to_add.z = item['z']
...
Tot slot commiten we deze data naar de databank, en sluiten we de sessie nadat we over elke rij in data geloopt hebben:
...
session.add(location_to_add)
session.commit()
...
session.close()
De volledige code van add_locations :
def add_locations(db,data):
"""
:return:
"""
Session = sessionmaker(bind=db.sqla_engine)
session = Session()
# loop over data to add and check if data is already in the db. If not ==> add
for index, item in data.iterrows():
exists = session.query(sqlalchemy.exists().where(orm_file.Location.name == item['locatie'])).scalar()
if not exists:
print('table: "Location" with column: "name" and value: {value} does not exist, adding data'.format(
value=item['locatie']))
location_to_add = orm_file.Location()
location_to_add.name = item['locatie']
location_to_add.description = item['beschrijving']
location_to_add.x = item['x']
location_to_add.y = item['y']
location_to_add.z = item['z']
print(location_to_add)
session.add(location_to_add)
session.commit()
else:
print(
'table: "Location" with column: "name" and value: {value} already existed, skip adding of data'.format(
value=item['locatie']))
session.close()
Raadpleeg je data in de databank
Je kan nu in dbeaver verifiëren dat de data toegevoegd is aan de heroku-hosted postgres databank!
Hoe maak ik zelf een databank aan voor mijn citizen science project
Introductie
In deze tutorial zullen we een postgres-database opzetten, gehost in de cloud via Heroku. We ontwerpen het databasemodel in dbdiagram.io en behandelen de import van gegevens uit een Excel-bestand met behulp van Python en SQLAlchemy.
Installatie
Enige voorbereiding is nodig!
Conda-omgeving
We moeten eerst een Python-omgeving opzetten in Conda. Voor deze tutorial gebruiken we Python 3.8. Pakketten kunnen via de commandline worden geïnstalleerd met behulp van:
conda install --file requirements.txt
de requirements.txt file is hier te downloaden.
Registreer je hier voor een Heroku-account: https://signup.heroku.com/
Helaas biedt Heroku vanaf eind November 2022 geen gratis credits meer aan:
Na registratie kan je je eerste app aanmaken:
Kies de naam van de app en je regio, klik op "Create app":
Postgres in de cloud via Heroku
Ga naar "resources" en selecteer "Heroku Postgres".Kies voor "Hobby-Dev":
Klik je net aangemaakte service aan, ga naar de "Settings" om de databank credentials te raadplegen. Je zal deze nodig hebben om te kunnen connecteren naar je databank:
Connectie naar je nieuwe databank
Er zijn verschillende manier om te connecteren naar de database.
Heroku CLI
Ga naar https://devcenter.heroku.com/articles/heroku-cli en volg daar het stappenplan om de Heroku CLI op te zetten in je commandline terminal.
Voor deze tutorial zullen we echter dbeaver gebruiken, dat iets gebruiksvriendelijker is.
Dbeaver
DBeaver is een gratis multi-platform databank tool voor ontwikkelaars, databasebeheerders, analisten en iedereen die met databases moet werken. Het ondersteunt alle populaire databases, inclusief degene die we in deze tutorial zullen gebruiken.
Om DBeaver te gebruiken, moet je al een versie van Postgres op je lokale machine geïnstalleerd hebben: https://www.postgresql.org/download/
Ga naar https://dbeaver.io/ om DBeaver te downloaden.
Open DBeaver nadat het geïnstalleerd is. Je kunt op het pictogram "new database connection" linksboven klikken om een verbinding te maken met de Heroku-database:
Onze databank bevat momenteel nog geen tabellen, maar daar zorgen we voor in de volgende stap.
Databank model
Maak je databank model aan
We zullen gebruik maken van dbdiagram.io om het databank model aan te maken. Eens ontworpen, kan deze geëxporteerd worden naar SQL code. Deze code kunnen we dan uitvoeren in dbeaver om de tabellen en alle relaties tussen de tabellen aan te maken.
In dit voorbeeld maken we 3 tabellen aan. Ze laten ons toe de meetwaarden van de sensoren op te slaan, alsook de meta-data en informatie over de locatie van de sensor.
Eens de tabellen aangemaakt zijn in dbdiagram.io klik je op "export to PostgreSQL". Dit maakt een .sql file aan die we in de volgende stap zullen gebruiken.
Maak de tabellen aan in dbeaver
Je zou de SQL-query kunnen starten met behulp van de Heroku CLI, een Python-script,... maar voor deze tutorial zullen we deze starten vanuit DBeaver.
Open DBeaver en maak verbinding met de database.
Open een nieuw script en plak hierin het .sql-bestand dat we hebben aangemaakt in dbdiagram.io.
Voer dit script uit (ook hier te downloaden: 10-create-tables.sql )
De tabellen zijn nu aangemaakt. Je kan ze bekijken door op "public scheme" te klikken en vervolgens op "ER Diagram":
Migreer je datasheets naar de databank
Voorbeeld csv file
Met de databank en (lege) tabellen op hun plaats is het tijd om te kijken naar het voorbeeld Excel-bestand, te vinden hier , dat we willen importeren.
Er zijn 3 tabbladen in het Excel-bestand:
Locaties, waar wat extra informatie staat over de locaties waar de sensoren zijn geplaatst.
Sensoren, een oplijsting van de verschillende sensoren.
Metingen, een oplijsting van de gegevens die door de sensoren zijn verzameld.
De afbeeldingen hieronder tonen de dummygegevens die in elk van de tabbladen zijn ingevoerd. Deze gegevens zullen we in onze databank uploaden: Locaties Metingen
Sensoren
Python en SQLalchemy
We zullen Python in combinatie met het SQLalchemy-pakket gebruiken om de gegevens in de Excel-sheets naar de database over te zetten. De volgende scripts (die hier terug te vinden zijn) zijn hiervoor gemaakt:
excel_parser.py : een parser om de Excel-tabbladen in te lezen en te transformeren, zodanig dat ze klaar zijn om in het databank model te plaatsen.
orm.py : bevat de SQLalchemy Object-Relational Mapping (ORM), zodat we gemakkelijk met onze databasestructuur kunnen werken in Python.
push-data-db.py : start dit bestand om de gegevens te lezen, te transformeren en in de databank te plaatsen!
Opmerking: je zal de credentials in "push-data-db.py" moeten aanpassen, zodat ze matchen op jouw database gegevens. DBASE = 'd2hto0sg05etiq'
USER = 'itwgxojqwqnqwl'
PASSWORD = ';-)'
HOST = 'ec2-34-248-169-69.eu-west-1.compute.amazonaws.com'
PORT = 5432
SCHEMA = 'public'
Nu maken we de connectie met de Heroku hosted postgres databank: de dbclass kan je vinden in dbutils.py . Het laat ons toe om vanuit python aan de slag te gaan met onze postgres databank:
Database connection for queries
---------------------------------
get instance of class
db = dbclass(dbase=DBASE,
user=USER,
password=PASSWORD,
port=PORT,
host=HOST)
test connection
concheck = db.connected()
print(concheck)
volgende stap, het importeren van de data in de excel sheets: sensors,measurements,locations = import_excel_data()
Vervolgens pushen we de data naar de databank: add_locations(db, data=locations)
add_sensors(db, data=sensors)
add_measurements(db, data=measurements)
Het is belangrijk deze bovenstaande 3 lijntjes in de juiste volgorde uit te voeren, daar je eerst de locatie data nodig hebt om ernaar te kunnen refereren in de sensor tabel. Hieronder zoomen we in op de add_locations functie:
In sessionmaker maken we een handle om te kunnen connecteren naar de heroku gehoste database.
Vervolgens itereren we over elke rij in data , waar we de locatie data kunnen vinden:
...
for index, item in data.iterrows():
...
Vervolgens checken we of de locaties al werden toegevoed in de databank (om duplicates te voorkomen): ...
exists = session.query(sqlalchemy.exists().where(orm_file.Location.name == item['locatie'])).scalar()
...
Als de data nog niet werd toegevoegd, maken we een Location instance aan via de orm_file , en hieraan voegen we de nodige variabelen toe ('locatie','beschrijving','x','y','z'): ...
location_to_add = orm_file.Location()
location_to_add.name = item['locatie']
location_to_add.description = item['beschrijving']
location_to_add.x = item['x']
location_to_add.y = item['y']
location_to_add.z = item['z']
...
Tot slot commiten we deze data naar de databank, en sluiten we de sessie nadat we over elke rij in data geloopt hebben: ...
session.add(location_to_add)
session.commit()
...
session.close()
De volledige code van add_locations : def add_locations(db,data):
"""
:return:
"""
Session = sessionmaker(bind=db.sqla_engine)
session = Session()
# loop over data to add and check if data is already in the db. If not ==> add
for index, item in data.iterrows():
exists = session.query(sqlalchemy.exists().where(orm_file.Location.name == item['locatie'])).scalar()
if not exists:
print('table: "Location" with column: "name" and value: {value} does not exist, adding data'.format(
value=item['locatie']))
location_to_add = orm_file.Location()
location_to_add.name = item['locatie']
location_to_add.description = item['beschrijving']
location_to_add.x = item['x']
location_to_add.y = item['y']
location_to_add.z = item['z']
print(location_to_add)
session.add(location_to_add)
session.commit()
else:
print(
'table: "Location" with column: "name" and value: {value} already existed, skip adding of data'.format(
value=item['locatie']))
session.close()
Raadpleeg je data in de databank
Je kan nu in dbeaver verifiëren dat de data toegevoegd is aan de heroku-hosted postgres databank!
Hoe publiceer ik de data van mijn citizen science project
Zenodo data flow
Een eenvoudige handleiding voor het uploaden van gegevens via de Zenodo API!
Zenodo biedt gratis hosting voor wetenschappelijke gegevens aan. Je kan ofwel naar de website gaan en data handmatig uploaden, of data publiceren en downloaden via de API. Deze tutorial implementeert de API om dummy gegevens te publiceren.
De API maakt automatisch publiceren, opslaan of hosten van uw gegevens online mogelijk, en het opent ook mogelijkheden voor dashboarding vanuit Zenodo.
Zenodo biedt ook de mogelijkheid om "communities" te creëren waar je controle hebt (goedkeuren en afwijzen) over welke gegevens opgenomen worden in de "community collection":
Door main.py uit te voeren (terug te vinden in deze repository: zenodo-api ) en enkele kleine aanpassingen te maken, worden dummy gegevens gepubliceerd in uw repository. U moet eerst een Zenodo-account aanmaken, dit kan eenvoudig op hun website.
Wees ervan bewust dat er 2 "websites" zijn:
De reguliere website.
Een sandbox-versie.
Deze delen uw account niet en u hebt een aparte log-in nodig om toegang te krijgen tot uw repository. De sandbox-versie kan worden gebruikt om zaken te testen. De gegevens daar worden waarschijnlijk regelmatig verwijderd, vertrouw hier dus alleen op voor testdoeleinden!
Afhankelijk van of u in de sandbox wil werken of niet, kan u dit aan het begin van het script selecteren:
sandbox = 0
if sandbox:
ACCESS_TOKEN = 'secret'
base_api = 'https://sandbox.zenodo.org/'
else:
ACCESS_TOKEN = 'secret'
base_api = 'https://zenodo.org/'
In de upload_and_publish functie wordt al het werk gedaan, laten we er doorheen gaan.
We testen eerst onze token die aangemaakt werd bij de account registratie op de Zenodo-website:
def upload_and_publish(input):
# test token
r = requests.get('{}api/deposit/depositions'.format(base_api),
params={'access_token': ACCESS_TOKEN})
print(r.status_code)
print(r.json())
Om het publiceren van gegevens te starten, maken we eerst een lege upload aan:
# empty upload
headers = {"Content-Type": "application/json"}
params = {'access_token': ACCESS_TOKEN}
r = requests.post('{}api/deposit/depositions'.format(base_api),
params=params,
json={},
# Headers are not necessary here since "requests" automatically
# adds "Content-Type: application/json", because we're using
# the "json=" keyword argument
# headers=headers,
headers=headers)
print(r.status_code)
print(r.json())
Vervolgens maken we een "bucket" aan die wordt gebruikt om het .txt-bestand vast te houden dat we willen uploaden.
Bewerk het pad om uw eigen dummy gegevensbestand te uploaden. De put-request vereist verder nog de 'access_token':
# bucket
bucket_url = r.json()["links"]["bucket"]
deposition_id = r.json()["id"]
# New API
filename = "test-data-zenodo.txt"
path = r"C:\repos\zenodo-flow\%s" % filename
# The target URL is a combination of the bucket link with the desired filename
# seperated by a slash.
with open(path, "rb") as fp:
r = requests.put(
"%s/%s" % (bucket_url, filename),
data=fp,
params=params,
)
r.json()
Je kan ook metadata toevoegen aan de put-request: dit kan je doen door een key genaamd metadata toe te voegen aan de data-parameter.
# add meta-data
data = {
'metadata': {
'title': 'My first upload',
'upload_type': 'dataset',
'description': 'This is my first upload',
'creators': [{'name': 'Van Loo, Maarten',
'affiliation': 'VITO'}]
}
}
r = requests.put('{}api/deposit/depositions/{}'.format(base_api,deposition_id),
params={'access_token': ACCESS_TOKEN},
data=json.dumps(data),
headers=headers)
print(r.status_code)
print(r.json())
Ten slotte verzenden we dit allemaal via de API:
r = requests.post('{}api/deposit/depositions/{}/actions/publish'.format(base_api,deposition_id),
params={'access_token': ACCESS_TOKEN})
print(r.status_code)
print(r.json())
Je kunt nu de gegevens verifiëren in je uploads op Zenodo:
thumb
Klik op de upload om alle informatie met betrekking tot deze upload te controleren:
de publisher (Maarten Van Loo)
de data file (test-data-zenodo.txt)
de publicatie datum (23/08/2022)
de DOI: (10.5281/zenodo.7016539)
License (CC zero v1.0 Universal)
Version (Version 1)
Ten slotte kan je ook het gegevensbestand downloaden en de upload verifiëren!
Hoe publiceer ik de data van mijn citizen science project
Zenodo data flow
Een eenvoudige handleiding voor het uploaden van gegevens via de Zenodo API!
Zenodo biedt gratis hosting voor wetenschappelijke gegevens aan. Je kan ofwel naar de website gaan en data handmatig uploaden, of data publiceren en downloaden via de API. Deze tutorial implementeert de API om dummy gegevens te publiceren.
De API maakt automatisch publiceren, opslaan of hosten van uw gegevens online mogelijk, en het opent ook mogelijkheden voor dashboarding vanuit Zenodo.
Zenodo biedt ook de mogelijkheid om "communities" te creëren waar je controle hebt (goedkeuren en afwijzen) over welke gegevens opgenomen worden in de "community collection":
Door main.py uit te voeren (terug te vinden in deze repository: zenodo-api ) en enkele kleine aanpassingen te maken, worden dummy gegevens gepubliceerd in uw repository. U moet eerst een Zenodo-account aanmaken, dit kan eenvoudig op hun website.
Wees ervan bewust dat er 2 "websites" zijn:
De reguliere website.
Een sandbox-versie.
Deze delen uw account niet en u hebt een aparte log-in nodig om toegang te krijgen tot uw repository. De sandbox-versie kan worden gebruikt om zaken te testen. De gegevens daar worden waarschijnlijk regelmatig verwijderd, vertrouw hier dus alleen op voor testdoeleinden! Afhankelijk van of u in de sandbox wil werken of niet, kan u dit aan het begin van het script selecteren: sandbox = 0
if sandbox:
ACCESS_TOKEN = 'secret'
base_api = 'https://sandbox.zenodo.org/'
else:
ACCESS_TOKEN = 'secret'
base_api = 'https://zenodo.org/'
In de upload_and_publish functie wordt al het werk gedaan, laten we er doorheen gaan.
We testen eerst onze token die aangemaakt werd bij de account registratie op de Zenodo-website: def upload_and_publish(input):
# test token
r = requests.get('{}api/deposit/depositions'.format(base_api),
params={'access_token': ACCESS_TOKEN})
print(r.status_code)
print(r.json())
Om het publiceren van gegevens te starten, maken we eerst een lege upload aan: # empty upload
headers = {"Content-Type": "application/json"}
params = {'access_token': ACCESS_TOKEN}
r = requests.post('{}api/deposit/depositions'.format(base_api),
params=params,
json={},
# Headers are not necessary here since "requests" automatically
# adds "Content-Type: application/json", because we're using
# the "json=" keyword argument
# headers=headers,
headers=headers)
print(r.status_code)
print(r.json())
Vervolgens maken we een "bucket" aan die wordt gebruikt om het .txt-bestand vast te houden dat we willen uploaden.
Bewerk het pad om uw eigen dummy gegevensbestand te uploaden. De put-request vereist verder nog de 'access_token': # bucket
bucket_url = r.json()["links"]["bucket"]
deposition_id = r.json()["id"]
# New API
filename = "test-data-zenodo.txt"
path = r"C:\repos\zenodo-flow\%s" % filename
# The target URL is a combination of the bucket link with the desired filename
# seperated by a slash.
with open(path, "rb") as fp:
r = requests.put(
"%s/%s" % (bucket_url, filename),
data=fp,
params=params,
)
r.json()
Je kan ook metadata toevoegen aan de put-request: dit kan je doen door een key genaamd metadata toe te voegen aan de data-parameter. # add meta-data
data = {
'metadata': {
'title': 'My first upload',
'upload_type': 'dataset',
'description': 'This is my first upload',
'creators': [{'name': 'Van Loo, Maarten',
'affiliation': 'VITO'}]
}
}
r = requests.put('{}api/deposit/depositions/{}'.format(base_api,deposition_id),
params={'access_token': ACCESS_TOKEN},
data=json.dumps(data),
headers=headers)
print(r.status_code)
print(r.json())
Ten slotte verzenden we dit allemaal via de API: r = requests.post('{}api/deposit/depositions/{}/actions/publish'.format(base_api,deposition_id),
params={'access_token': ACCESS_TOKEN})
print(r.status_code)
print(r.json())
Je kunt nu de gegevens verifiëren in je uploads op Zenodo:
Klik op de upload om alle informatie met betrekking tot deze upload te controleren:
de publisher (Maarten Van Loo)
de data file (test-data-zenodo.txt)
de publicatie datum (23/08/2022)
de DOI: (10.5281/zenodo.7016539)
License (CC zero v1.0 Universal)
Version (Version 1)
Ten slotte kan je ook het gegevensbestand downloaden en de upload verifiëren!
(Deze richtlijnen worden momenteel opgemaakt in een co-creatie proces. Aanbeveling dus onder voorbehoud. Deze worden momenteel geregeld geüpdatet. Naar het einde van 2021 toe worden deze richtlijnen gefinaliseerd)
Criteria/aspecten om aantal sensoren en locaties te bepalen
doelstelling : wat wil je meten?
omvang van het gebied
gewenst ruimtelijk detail niveau (hoe meer → hoe beter)
hydrologisch systeem (bv. waar zijn cruciale/grote/belangrijke veranderingen te verwachten)
beschikbaar budget en prijs van de beoogde sensor (zie sensor criteria)
waar verwacht je ruimtelijke verschillen ? (bv. op basis van schepstalen)
op welke locaties/zones verwacht je (hoge) temporele variatie ? (daar is de toegevoegde waarde van sensoren het grootste)
combineren van locaties met schepstalen en locaties met sensoren (zie vorig criterium) leidt tot een gericht gedifferentieerde ruimtelijke dekking
in specifieke omstandigheden of bij specifieke doelstellingen: sensoren op verschillende diepte en/of op verschillende positie in cross-sectie
energievoorziening (electriciteit, batterij, zonnepanelen)
toegankelijkheid en bereikbaarheid
vegetatie (hinder/onderhoud)
vergunningen en toelatingen
risico op diefstal/vandalisme (mogelijkheid tot beveiliging)
connectiviteit voor datacommunicatie
Hierbij is een afweging van criteria/vereisten t.o.v. budget (aankoop + installatie + onderhoud) belangrijk!
Praktische tips & tricks
Meestal is het een goede aanpak om:
te starten met meer locaties aan te duiden
vervolgens prioriteiten toe te kennen en criteria af te wegen
en vervolgens te optimaliseren
Het is ook nuttig om wat ‘back-up locaties’ te hebben indien sommige gewenste locaties praktisch niet haalbaar of moeilijk blijken.
Een getrapte aanpak is ook mogelijk, waarbij je o.b.v. sensoren op een beperkt aantal locaties een beter inzicht verkrijgt over het systeem en de ruimtelijk variabiliteit en je dit vervolgens gebruikt om extra locaties toe te voegen.
info grafe +
.jpg){kind=link}
.jpg){kind=link}
tekening +
This is an example service to illustrate the Hoppin Punt Service information
This page describes the information model for a service to be deployed on a HoppinPunt
A service is defined by the following elements
Identification
A name for the service ServiceName mybike
a Formal identifier ServiceIdentifier hp.gent.12
a version of the service Version 1.0
the service type type mobiliteit MobilityType fiets +
This page describes the information model for a service to be deployed on a HoppinPunt
A service is defined by the following elements
Identification
A name for the service
a Formal identifier
a version of the service
the service type +
This page describes the information model for a service to be deployed on a HoppinPunt
A service is defined by the following elements
Identification
A name for the service
a Formal identifier
a version of the service
the service type
Hoppin informatie architectuur +
Dit is een aggregaat klasse voor informatie over een Hoppin Punt.
Een Hoppin Punt heeft de volgende eigenschappen :
Identificatie
Hoppin Punt identificatie
HPId
rest
HPAdmin ( NeededForHPUseCase : ? (?, ?) ) HPGebruiksStats ( NeededForHPUseCase : ? (?, ?) ) HPIdentificatie ( NeededForHPUseCase : ? (?, ?) ) HPServices ( NeededForHPUseCase : ? (?, ?) ) HPStatus ( NeededForHPUseCase : ? (?, ?) ) HPType ( NeededForHPUseCase : ? (?, ?) ) +
Dit is de landing pagina van de beschrijving van de informatie architectuur van een Hoppin punt, en is een consolidatie van de werkgroepen van dit traject.
Deze informatie architectuur bestaat uit de volgende delen :
Hoppin punt informatie architectuur
Hoppin Service informatie architectuur
en ziet er in grafische vorm als volgt uit (noot: een vergrote versie van de Hoppin informatie architectuur is beschikbaar via deze link ):
De volgende tabellen bevatten de beschrijving van het informatiemodel in de vorm van de verwachte velden. Dit is gebaseerd op model van TOMP-API zoals gespecificeerd in [1]
Hoppin punt information model
Attribuut
Waarde
Uitleg
HPType
regionaal, buurt, lokaal
het type hoppin punt
HPIdentificatie
Voor de identificatie van een hoppin punt worden de volgende 3 attributen gebruikt
stationID
Een uniek identificatie van het Hoppin punt in de vorm van een URI. Dit wordt uitgegeven door MOW(?)
Naam
informele naam van het hoppin punt
Versie
Versie van het hoppin punt informatie model
HPAdmin
Informatie nodig voor de administratie van een hopping punt
Beheerder
Aanspreekpunt voor het hoppin punt.
HPLayout
bevat o.a. de geografische layout van het hoppin punt
locatie
address, geoJSON
locatie van het hoppin punt
toegankelijkheid
rolstoelvriendelijk, etc
toegankelijkheid van het hoppin punt voor gebruikers
GISModel
GIS model van het hoppin punt in een open formaat (e.g. GML, Simple Features)
HPServices
De lijst van services die dit hoppin punt aanbiedt
HPServices
{HPServiceIdentificatie}
identificatie van de service
Status
online, offline, inactief
status van de service voor dit hoppin punt
HPStatus
offline, online inactief, onbekend
status van het hoppin punt
Gebruiksstatistieken
Overall statistieken van het hoppin punt
Gebruikersprofielen
aantallen gebruikers per gebruikersgroep (leeftijd, geslacht, etc)
ServiceInformatie
{HPServiceInformatie}
lijst van serviceinformatie zoals gedefinieerd per service
Hoppin punt Service information model
Attribuut
Waarde
Uitleg
HPServiceType
type service
support
food, post, ev-charging, aed, toiletten, lockers, fietsherstel, beheerder, social, video camera, reclame
het type support service dat aangeboden wordt
mobiliteit
deelwagen, fiets, step, trein, bus, tram, taxi, waterbus, carpool
het type mobiliteitsservice die aangeboden wordt
HPServiceIdentificatie
Voor de identificatie van een hoppin punt service worden de volgende attributen gebruikt
URI
Een uniek identificatie van de Hoppin punt service. Dit wordt uitgegeven door MOW(?)
Naam
informele naam van de service
Short name
korte naam van de service
Versie
Versie van het hoppin punt service informatie model
HPServiceOperator
Uitvoerder van den service
URL
Een uniek identificatie van de service operator
Naam
informele naam van de operator
contact details
phone number, email, address,
HPServiceInformatie
Toegang
Een eenduidige beschrijving hoe en waar een gebruiker toegang kan krijgen tot de service
Pricing
Prijsstelling van de service (eenmalig, abonnement, etc)
ServiceInfo
Volledige beschrijving van de servicebeschikbaarheid: tijdstabellen, diensten, verbindingen. modaliteiten
ServiceAPI
[TOMP, GTFS, Other]
beschrijving van de standaard API die ondersteund wordt
ServiceAccess
http://
URL naar de standaard API
Een formulier om een hoppin punt te beschrijven op basis van deze informatie is hier te vinden: Hoppin punt informatie
Een formulier om een service te beschrijven hier: Hoppin punt service informatie
Een Hoppinpunt is een vervoersknooppunt waar:
parkeermogelijkheden voor verschillende personenwagens en fietsen zijn en/of
verschillende vervoersmogelijkheden (trein, bus, deelfiets, ...) aangeboden worden onder de vorm van onder meer deelsystemen, waardoor reizigers met het geschikte vervoermiddel een verplaatsing kunnen maken.
Hoppin bundelt verschillende vervoersoplossingen in Vlaanderen en helpt reizigers zich zo efficiënt mogelijk te verplaatsen naar hun bestemming. +