diff --git a/Examples/APIDemo.ipynb b/Examples/APIDemo.ipynb deleted file mode 100644 index c2f5518..0000000 --- a/Examples/APIDemo.ipynb +++ /dev/null @@ -1,296 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "__author__ = 'stephanie'\n", - "\n", - "#Demo Created and run against little bear river demo database. scripts are located at \n", - "#https://github.com/ODM2/ODM2/tree/master/usecases/littlebearriver/sampledatabases\n", - "\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import dates\n", - "%matplotlib notebook\n", - "# inline\n", - "\n", - "from odm2api.ODMconnection import dbconnection\n", - "from odm2api.ODM2.services.readService import *\n", - "\n", - "\n", - "# Create a connection to the ODM2 database\n", - "# ----------------------------------------\n", - "\n", - "#createconnection (dbtype, servername, dbname, username, password)\n", - "session_factory = dbconnection.createConnection('mysql', 'localhost', 'ODM2', 'ODM', 'odm')#mysql\n", - "#session_factory = dbconnection.createConnection('connection type: sqlite|mysql|mssql|postgresql', '/your/path/to/db/goes/here', 2.0)#sqlite\n", - "# session_factory= dbconnection.createConnection('mssql', \"(local)\", \"LBRODM2\", \"ODM\", \"odm\")#win MSSQL\n", - "# session_factory= dbconnection.createConnection('mssql', \"odm2\", \"\", \"ODM\", \"odm\")#mac/linux MSSQL" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "_session = session_factory.getSession()\n", - "\n", - "read = ReadODM2(session_factory)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Run some basic sample queries.\n", - "# ------------------------------\n", - "# Get all of the variables from the database and print their names to the console\n", - "allVars = read.getVariables()\n", - "\n", - "for x in allVars:\n", - " print x.VariableCode + \": \" + x.VariableNameCV" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Jeff Horsburgh\nNancy Mesner\nAmber Spackman\nErin Jones\nJanet Barnette\nJason Bahr\nChris Cox\nUnknown Person\nLisa Ward\n\n-------- Information about an Affiliation ---------\nJeff: 1\nJeff: 2\nAmber: 3\nNancy: 4\nAmber: 6\nJeff: 6\nErin: 46\nJanet: 48\nJason: 45\nChris: 45\nUnknown: 45\nLisa: 47\n" - ] - } - ], - "source": [ - "# Get all of the people from the database\n", - "allPeople = read.getPeople()\n", - "\n", - "for x in allPeople:\n", - " print x.PersonFirstName + \" \" + x.PersonLastName\n", - "\n", - "try:\n", - " print \"\\n-------- Information about an Affiliation ---------\"\n", - " allaff = read.getAffiliations()\n", - " for x in allaff:\n", - " print x.PersonObj.PersonFirstName + \": \" + str(x.OrganizationID)\n", - "except Exception as e:\n", - " print \"Unable to demo getAllAffiliations\", e" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Get all of the SamplingFeatures from the database that are Sites\n", - "\n", - "try:\n", - " siteFeatures = read.getSamplingFeatures(type='Site')\n", - " numSites = len(siteFeatures)\n", - " print \"\\n-------- Information about an SamplingFeature of type 'Site'---------\"\n", - " for x in siteFeatures:\n", - " print x.SamplingFeatureCode + \": \" + x.SamplingFeatureName\n", - "except Exception as e:\n", - " print \"Unable to demo getSamplingFeaturesByType\", e\n", - "\n", - "\n", - "# Now get the SamplingFeature object for a SamplingFeature code\n", - "try:\n", - " sf = read.getSamplingFeatures(codes= ['USU-LBR-Mendon'])[0]\n", - " \n", - " print \"\\n-------- Information about an individual SamplingFeature ---------\"\n", - " print \"The following are some of the attributes of a SamplingFeature retrieved using getSamplingFeatureByCode(): \\n\"\n", - " print \"SamplingFeatureCode: \" + sf.SamplingFeatureCode\n", - " print \"SamplingFeatureName: \" + sf.SamplingFeatureName\n", - " print \"SamplingFeatureDescription: %s\" % sf.SamplingFeatureDescription\n", - " print \"SamplingFeatureGeotypeCV: %s\" % sf.SamplingFeatureGeotypeCV\n", - " print \"SamplingFeatureGeometry: %s\" % sf.FeatureGeometry\n", - " print \"Elevation_m: %s\" % str(sf.Elevation_m)\n", - "except Exception as e:\n", - " print \"Unable to demo getSamplingFeatureByCode: \", e" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "#add sampling feature\n", - "print \"\\n------------ Create Sampling Feature --------- \\n\",\n", - "try:\n", - " from odm2api.ODM2.models import SamplingFeatures\n", - " newsf = SamplingFeatures()\n", - " session = session_factory.getSession()\n", - " newsf.FeatureGeometry = \"POINT(-111.946 41.718)\"\n", - " newsf.Elevation_m=100\n", - " newsf.ElevationDatumCV=sf.ElevationDatumCV\n", - " newsf.SamplingFeatureCode= \"TestSF\"\n", - " newsf.SamplingFeatureDescription = \"this is a test to add Feature Geomotry\"\n", - " newsf.SamplingFeatureGeotypeCV= \"Point\"\n", - " newsf.SamplingFeatureTypeCV=sf.SamplingFeatureTypeCV\n", - " newsf.SamplingFeatureUUID= sf.SamplingFeatureUUID+\"2\"\n", - " session.add(newsf)\n", - " #session.commit()\n", - " print \"new sampling feature added to database\", newsf\n", - "\n", - "except Exception as e :\n", - " print \"error adding a sampling feature: \" + str(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Drill down and get objects linked by foreign keys\n", - "print \"\\n------------ Foreign Key Example --------- \\n\",\n", - "try:\n", - " # Call getResults, but return only the first result\n", - " firstResult = read.getResult()[0]\n", - " print \"The FeatureAction object for the Result is: \", firstResult.FeatureActionObj\n", - " print \"The Action object for the Result is: \", firstResult.FeatureActionObj.ActionObj\n", - " print (\"\\nThe following are some of the attributes for the Action that created the Result: \\n\" +\n", - " \"ActionTypeCV: \" + firstResult.FeatureActionObj.ActionObj.ActionTypeCV + \"\\n\" +\n", - " \"ActionDescription: \" + firstResult.FeatureActionObj.ActionObj.ActionDescription + \"\\n\" +\n", - " \"BeginDateTime: \" + str(firstResult.FeatureActionObj.ActionObj.BeginDateTime) + \"\\n\" +\n", - " \"EndDateTime: \" + str(firstResult.FeatureActionObj.ActionObj.EndDateTime) + \"\\n\" +\n", - " \"MethodName: \" + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodName + \"\\n\" +\n", - " \"MethodDescription: \" + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodDescription)\n", - "except Exception as e:\n", - " print \"Unable to demo Foreign Key Example: \", e" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n------- Example of Retrieving Attributes of a Time Series Result -------\nThe following are some of the attributes for the TimeSeriesResult retrieved using getTimeSeriesResultByResultID(): \nResultTypeCV: Time series coverage\nProcessingLevel: Raw data\nSampledMedium: Not applicable\nVariable: USU3: Battery voltage\nAggregationStatistic: Minimum\nElevation_m: 1345.0\nSamplingFeature: USU-LBR-Mendon - Little Bear River at Mendon Road near Mendon, Utah\n" - ] - } - ], - "source": [ - "# Now get a particular Result using a ResultID\n", - "print \"\\n------- Example of Retrieving Attributes of a Time Series Result -------\"\n", - "try:\n", - " #tsResult = read.getTimeSeriesResultByResultId(1)\n", - " tsResult = read.getResults(ids = [1])[0]\n", - " print (\n", - " \"The following are some of the attributes for the TimeSeriesResult retrieved using getTimeSeriesResultByResultID(): \\n\" +\n", - " \"ResultTypeCV: \" + tsResult.ResultTypeCV + \"\\n\" +\n", - " # Get the ProcessingLevel from the TimeSeriesResult's ProcessingLevel object\n", - " \"ProcessingLevel: \" + tsResult.ProcessingLevelObj.Definition + \"\\n\" +\n", - " \"SampledMedium: \" + tsResult.SampledMediumCV + \"\\n\" +\n", - " # Get the variable information from the TimeSeriesResult's Variable object\n", - " \"Variable: \" + tsResult.VariableObj.VariableCode + \": \" + tsResult.VariableObj.VariableNameCV + \"\\n\"\n", - " \"AggregationStatistic: \" + tsResult.AggregationStatisticCV + \"\\n\" +\n", - " \"Elevation_m: \" + str(sf.Elevation_m) + \"\\n\" +\n", - " # Get the site information by drilling down\n", - " \"SamplingFeature: \" + tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureCode + \" - \" +\n", - " tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureName)\n", - "except Exception as e:\n", - " print \"Unable to demo Example of retrieving Attributes of a time Series Result: \", e" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "# Get the values for a particular TimeSeriesResult\n", - "print \"\\n-------- Example of Retrieving Time Series Result Values ---------\"\n", - "\n", - "\n", - "tsValues = read.getResultValues(resultid =1) # Return type is a pandas dataframe\n", - "# Print a few Time Series Values to the console\n", - "try:\n", - " print tsValues.head()\n", - "except Exception as e:\n", - " print e\n", - "\n", - "# Plot the time series\n", - "\n", - "try:\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(111)\n", - " tsValues.plot(x='ValueDateTime', y='DataValue', kind='line',\n", - " title=tsResult.VariableObj.VariableNameCV + \" at \" + tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureName,\n", - " ax=ax)\n", - " ax.set_ylabel(tsResult.VariableObj.VariableNameCV + \" (\" + tsResult.UnitsObj.UnitsAbbreviation + \")\")\n", - " ax.set_xlabel(\"Date/Time\")\n", - " ax.xaxis.set_minor_locator(dates.MonthLocator())\n", - " ax.xaxis.set_minor_formatter(dates.DateFormatter('%b'))\n", - " ax.xaxis.set_major_locator(dates.YearLocator())\n", - " ax.xaxis.set_major_formatter(dates.DateFormatter('\\n%Y'))\n", - " ax.grid(True)\n", - " plt.show()\n", - "except Exception as e:\n", - " print \"Unable to demo plotting of tsValues: \", e" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2.0 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/Examples/ReadMe.md b/Examples/ReadMe.md new file mode 100644 index 0000000..e8b53f0 --- /dev/null +++ b/Examples/ReadMe.md @@ -0,0 +1,7 @@ +## Sample Jupyter notebooks +These two notebooks are complete, extended examples that illustrate reading from ODM2 databases and using the resulting data and metadata. They use SQLite ODM2 file databases that can be [downloaded here](https://github.com/ODM2/ODM2PythonAPI/tree/master/Examples/data). A conda environment to run these notebooks can be created with the conda environment file [clientenvironment.yml](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/clientenvironment.yml). + +1. [WaterQualityMeasurements_RetrieveVisualize.ipynb](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb) +2. [TimeSeries_RetrieveVisualize.ipynb](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/TimeSeries_RetrieveVisualize.ipynb) + +For detailed documentation of the ODM2 Python API, see http://odm2.github.io/ODM2PythonAPI/ diff --git a/Examples/Sample 1.1.py b/Examples/Sample 1.1.py deleted file mode 100644 index 03b986e..0000000 --- a/Examples/Sample 1.1.py +++ /dev/null @@ -1,97 +0,0 @@ -from __future__ import (absolute_import, division, print_function) - -import sys -import os -from odm2api.ODMconnection import dbconnection -import pprint -from odm2api.ODM1_1_1.services import SeriesService - -__author__ = 'stephanie' - -this_file = os.path.realpath(__file__) -directory = os.path.dirname(this_file) -sys.path.insert(0, directory) - - - -# ---------------------------------------- -conns = [ - #connection to the ODM1 database - dbconnection.createConnection('mysql', 'jws.uwrl.usu.edu', 'odm', "ODM", "ODM123!!", 1.1), - #connection to the ODM2 database - dbconnection.createConnection('mssql', '(local)', 'odm2', 'ODM', 'odm', 2.0)] - - -for conn in conns: - pp = pprint.PrettyPrinter(indent=8) - - print - print "************************************************" - print "\t\tODM2 -> ODM1 Demo: " - print "************************************************" - print - - odm1service = SeriesService(conn) - - pp.pprint(conn) - - print - print "************************************************" - print "\t\tUnits: get_all_units()" - print "************************************************" - print - - pp.pprint(odm1service.get_unit_by_id(321)) - - print - print "************************************************" - print "\t\tSites: get_all_sites()" - print "************************************************" - print - - pp.pprint(odm1service.get_all_sites()) - - print - print "************************************************" - print "\t\tMethods: get_all_methods()" - print "************************************************" - print - - pp.pprint(odm1service.get_method_by_id(8)) - - print - print "************************************************" - print "\t\tVariables: get_all_variables()" - print "************************************************" - print - - pp.pprint(odm1service.get_variable_by_id(10)) - - print - print "************************************************" - print "\t\tData Sources: get_all_Source()" - print "************************************************" - print - - pp.pprint(odm1service.get_all_sources()) - - print - print "************************************************" - print "\t\tSeries: get_all_series()" - print "************************************************" - print - - ser = odm1service.get_all_series() - - pp.pprint(ser) - - - print - print "************************************************" - print "\t\tData Values: get_all_DataValues()" - print "************************************************" - print - - pp.pprint(odm1service.get_values_by_series(ser[0].id)) - - print "The end" diff --git a/Examples/Sample.py b/Examples/Sample.py deleted file mode 100644 index 891b764..0000000 --- a/Examples/Sample.py +++ /dev/null @@ -1,165 +0,0 @@ -from __future__ import (absolute_import, division, print_function) - -__author__ = 'stephanie' - -#import matplotlib.pyplot as plt - - - - -from odm2api.ODMconnection import dbconnection -from odm2api.ODM2.services.readService import * -from odm2api.ODM2.services import CreateODM2 -# Create a connection to the ODM2 database -# ---------------------------------------- - - -#connect to database -# createconnection (dbtype, servername, dbname, username, password) -# session_factory = dbconnection.createConnection('connection type: sqlite|mysql|mssql|postgresql', '/your/path/to/db/goes/here', 2.0)#sqlite - - -# session_factory = dbconnection.createConnection('postgresql', 'localhost', 'odm2', 'ODM', 'odm') -# session_factory = dbconnection.createConnection('mysql', 'localhost', 'odm2', 'ODM', 'odm')#mysql -session_factory= dbconnection.createConnection('mssql', "(local)", "ODM2", "ODM", "odm")#win MSSQL -# session_factory= dbconnection.createConnection('mssql', "arroyoodm2", "", "ODM", "odm")#mac/linux MSSQL -# session_factory = dbconnection.createConnection('sqlite', 'path/to/ODM2.sqlite', 2.0) - - - - -#_session = session_factory.getSession() -read = ReadODM2(session_factory) -create = CreateODM2(session_factory) - - -# Run some basic sample queries. -# ------------------------------ -# Get all of the variables from the database and print their names to the console -allVars = read.getVariables() -print ("\n-------- Information about Variables ---------") -for x in allVars: - print(x.VariableCode + ": " + x.VariableNameCV) - - - -# Get all of the people from the database -allPeople = read.getPeople() -print ("\n-------- Information about People ---------") -for x in allPeople: - print(x.PersonFirstName + " " + x.PersonLastName) - -try: - print("\n-------- Information about an Affiliation ---------") - allaff = read.getAffiliations() - for x in allaff: - print(x.PersonObj.PersonFirstName + ": " + str(x.OrganizationID)) -except Exception as e: - print("Unable to demo getAllAffiliations", e) - -# Get all of the SamplingFeatures from the database that are Sites -try: - print ("\n-------- Information about Sites ---------") - siteFeatures = read.getSamplingFeatures(type= 'site') - - # siteFeatures = read.getSamplingFeatures(type='Site') - numSites = len(siteFeatures) - print ("Successful query") - for x in siteFeatures: - print(x.SamplingFeatureCode + ": " + x.SamplingFeatureTypeCV ) -except Exception as e: - print("Unable to demo getSamplingFeaturesByType", e) - - -# Now get the SamplingFeature object for a SamplingFeature code -try: - sf = read.getSamplingFeatures(codes=['USU-LBR-Mendon'])[0] - print(sf) - print("\n-------- Information about an individual SamplingFeature ---------") - print("The following are some of the attributes of a SamplingFeature retrieved using getSamplingFeatureByCode(): \n") - print("SamplingFeatureCode: " + sf.SamplingFeatureCode) - print("SamplingFeatureName: " + sf.SamplingFeatureName) - print("SamplingFeatureDescription: %s" % sf.SamplingFeatureDescription) - print("SamplingFeatureGeotypeCV: %s" % sf.SamplingFeatureGeotypeCV) - print("SamplingFeatureGeometry: %s" % sf.FeatureGeometry) - print("Elevation_m: %s" % str(sf.Elevation_m)) -except Exception as e: - print("Unable to demo getSamplingFeatureByCode: ", e) - -#add sampling feature -print("\n------------ Create Sampling Feature --------- \n") -try: - # from odm2api.ODM2.models import SamplingFeatures - session = session_factory.getSession() - newsf = Sites(FeatureGeometryWKT = "POINT(-111.946 41.718)", Elevation_m=100, ElevationDatumCV=sf.ElevationDatumCV, - SamplingFeatureCode= "TestSF",SamplingFeatureDescription = "this is a test in sample.py", - SamplingFeatureGeotypeCV= "Point", SamplingFeatureTypeCV=sf.SamplingFeatureTypeCV,SamplingFeatureUUID= sf.SamplingFeatureUUID+"2", - SiteTypeCV="cave", Latitude= "100", Longitude= "-100", SpatialReferenceID= 0) - - c=create.createSamplingFeature(newsf) - #session.commit() - print("new sampling feature added to database", c) - -except Exception as e : - print("error adding a sampling feature: " + str(e)) - - -# Drill down and get objects linked by foreign keys -print("\n------------ Foreign Key Example --------- \n",) -try: - # Call getResults, but return only the first result - firstResult = read.getResults()[0] - print("The FeatureAction object for the Result is: ", firstResult.FeatureActionObj) - print("The Action object for the Result is: ", firstResult.FeatureActionObj.ActionObj) - print ("\nThe following are some of the attributes for the Action that created the Result: \n" + - "ActionTypeCV: " + firstResult.FeatureActionObj.ActionObj.ActionTypeCV + "\n" + - "ActionDescription: " + firstResult.FeatureActionObj.ActionObj.ActionDescription + "\n" + - "BeginDateTime: " + str(firstResult.FeatureActionObj.ActionObj.BeginDateTime) + "\n" + - "EndDateTime: " + str(firstResult.FeatureActionObj.ActionObj.EndDateTime) + "\n" + - "MethodName: " + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodName + "\n" + - "MethodDescription: " + firstResult.FeatureActionObj.ActionObj.MethodObj.MethodDescription) -except Exception as e: - print("Unable to demo Foreign Key Example: ", e) - - -# Now get a particular Result using a ResultID -print("\n------- Example of Retrieving Attributes of a Result -------") -try: - tsResult = read.getResults(ids = [1])[0] - print ( - "The following are some of the attributes for the TimeSeriesResult retrieved using getResults(ids=[1]): \n" + - "ResultTypeCV: " + tsResult.ResultTypeCV + "\n" + - # Get the ProcessingLevel from the TimeSeriesResult's ProcessingLevel object - "ProcessingLevel: " + tsResult.ProcessingLevelObj.Definition + "\n" + - "SampledMedium: " + tsResult.SampledMediumCV + "\n" + - # Get the variable information from the TimeSeriesResult's Variable object - "Variable: " + tsResult.VariableObj.VariableCode + ": " + tsResult.VariableObj.VariableNameCV + "\n" - #"AggregationStatistic: " + tsResult.AggregationStatisticCV + "\n" + - - # Get the site information by drilling down - "SamplingFeature: " + tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureCode + " - " + - tsResult.FeatureActionObj.SamplingFeatureObj.SamplingFeatureName) -except Exception as e: - print("Unable to demo Example of retrieving Attributes of a time Series Result: ", e) - -# Get the values for a particular TimeSeriesResult -print("\n-------- Example of Retrieving Time Series Result Values ---------") - -tsValues = read.getResultValues(resultids = [1]) # Return type is a pandas datafram - -# Print a few Time Series Values to the console -# tsValues.set_index('ValueDateTime', inplace=True) -try: - print(tsValues.head()) -except Exception as e: - print(e) - -# Plot the time series - -try: - plt.figure() - ax=tsValues.plot(x='ValueDateTime', y='DataValue') - - plt.show() -except Exception as e: - print("Unable to demo plotting of tsValues: ", e) diff --git a/Examples/TimeSeries_RetrieveVisualize.ipynb b/Examples/TimeSeries_RetrieveVisualize.ipynb new file mode 100644 index 0000000..e60ecab --- /dev/null +++ b/Examples/TimeSeries_RetrieveVisualize.ipynb @@ -0,0 +1,695 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ODM2 API: Retrieve, manipulate and visualize ODM2 time series data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example shows how to use the ODM2 Python API (`odm2api`) to connect to an ODM2 database, retrieve data, and analyze and visualize the data. The [database (USU_LittleBearRiver_timeseriesresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite) contains [\"timeSeriesCoverage\"-type results](http://vocabulary.odm2.org/resulttype/timeSeriesCoverage/).\n", + "\n", + "This example uses SQLite for the database because it doesn't require a server. However, the ODM2 Python API demonstrated here can alse be used with ODM2 databases implemented in MySQL, PostgreSQL or Microsoft SQL Server.\n", + "\n", + "More details on the ODM2 Python API and its source code and latest development can be found at https://github.com/ODM2/ODM2PythonAPI\n", + "\n", + "[Emilio Mayorga](https://github.com/emiliom/). Last updated 2019-5-10." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adapted from notebook https://big-cz.github.io/notebook_data_demo/notebooks/2017-06-24-odm2api_sample_fromsqlite/, based on earlier code and an ODM2 database from [Jeff Horsburgh's group](http://jeffh.usu.edu) at Utah State University." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "import pandas as pd\n", + "\n", + "import odm2api\n", + "from odm2api.ODMconnection import dbconnection\n", + "import odm2api.services.readService as odm2rs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "u'0.24.2'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**odm2api version used** to run this notebook:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.7.1+12.g6997f36'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "odm2api.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Connect to the ODM2 SQLite Database\n", + "\n", + "This example uses an ODM2 SQLite database file loaded with a sensor-based, high-frequency temperature time series from a site in the [Little Bear River, in Logan, Utah, from Utah State University](http://littlebearriver.usu.edu/). The [database (USU_LittleBearRiver_timeseriesresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite) contains [\"timeSeriesCoverage\"-type results](http://vocabulary.odm2.org/resulttype/timeSeriesCoverage/).\n", + "\n", + "The example database is located in the `data` sub-directory." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign directory paths and SQLite file name\n", + "dbname_sqlite = \"USU_LittleBearRiver_timeseriesresults_ODM2.sqlite\"\n", + "\n", + "sqlite_pth = os.path.join(\"data\", dbname_sqlite)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Database connection successful!\n" + ] + } + ], + "source": [ + "try:\n", + " session_factory = dbconnection.createConnection('sqlite', sqlite_pth)\n", + " read = odm2rs.ReadODM2(session_factory)\n", + " print(\"Database connection successful!\")\n", + "except Exception as e:\n", + " print(\"Unable to establish connection to the database: \", e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Some Basic Queries on the ODM2 Database\n", + "\n", + "This section shows some examples of how to use the API to run both simple and more advanced queries on the ODM2 database, as well as how to examine the query output in convenient ways thanks to Python tools. The notebook [WaterQualityMeasurements_RetrieveVisualize.ipynb](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb) includes more extensive examples of `odm2api`-based querying and examinations of the information that is returned.\n", + "\n", + "Simple query functions like **getVariables( )** return objects similar to the entities in ODM2, and individual attributes can then be retrieved from the objects returned. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "USU36: Temperature\n" + ] + } + ], + "source": [ + "allVars = read.getVariables()\n", + "\n", + "for x in allVars:\n", + " print('{}: {}'.format(x.VariableCode, x.VariableNameCV))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SamplingFeatures\n", + "Request all sampling features, then examine them. Only one sampling feature is present, with `SamplingFeatureTypeCV` type `Site`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sf_lst = read.getSamplingFeatures()\n", + "len(sf_lst)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ElevationDatumCV': u'NGVD29',\n", + " 'Elevation_m': 1345.0,\n", + " 'FeatureGeometryWKT': u'POINT (-111.946402 41.718473)',\n", + " 'SamplingFeatureCode': u'USU-LBR-Mendon',\n", + " 'SamplingFeatureDescription': None,\n", + " 'SamplingFeatureGeotypeCV': u'Point',\n", + " 'SamplingFeatureID': 1,\n", + " 'SamplingFeatureName': u'Little Bear River at Mendon Road near Mendon, Utah',\n", + " 'SamplingFeatureTypeCV': u'Site',\n", + " 'SamplingFeatureUUID': u'6c74a4bd-e1d4-11e5-95b8-f45c8999816f',\n", + " '_sa_instance_state': }" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vars(sf_lst[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "USU-LBR-Mendon: Little Bear River at Mendon Road near Mendon, Utah\n" + ] + } + ], + "source": [ + "print('{}: {}'.format(sf_lst[0].SamplingFeatureCode, sf_lst[0].SamplingFeatureName))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Results and Actions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also drill down and get objects linked by foreign keys. The API returns related objects in a nested hierarchy so they can be interrogated in an object oriented way. So, if I use the **getResults( )** function to return a Result from the database (e.g., a \"Time Series\" Result), I also get the associated Action that created that Result (e.g., an \"Observation\" Action)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# What's the total number of results in the database?\n", + "len(read.getResults())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ResultID for the Result is: 1\n", + "('The FeatureAction object for the Result is: ', )\n", + "('The Action object for the Result is: ', )\n", + "\n", + "The following are some of the attributes for the Action that created the Result: \n", + "ActionTypeCV: Observation\n", + "ActionDescription: An observation action that generated a time series result.\n", + "BeginDateTime: 2007-08-16 16:30:00\n", + "EndDateTime: 2009-01-16 12:30:00\n", + "MethodName: Quality Control Level 1 Data Series created from raw QC Level 0 data using ODM Tools.\n", + "MethodDescription: Quality Control Level 1 Data Series created from raw QC Level 0 data using ODM Tools.\n" + ] + } + ], + "source": [ + "try:\n", + " # Call getResults, but return only the first Result\n", + " firstResult = read.getResults()[0]\n", + " frfa = firstResult.FeatureActionObj\n", + " frfaa = firstResult.FeatureActionObj.ActionObj\n", + " print(\"The ResultID for the Result is: {}\".format(firstResult.ResultID))\n", + " print(\"The FeatureAction object for the Result is: \", frfa)\n", + " print(\"The Action object for the Result is: \", frfaa)\n", + " \n", + " # Print some Action attributes in a more human readable form\n", + " print(\"\\nThe following are some of the attributes for the Action that created the Result: \")\n", + " print(\"ActionTypeCV: {}\".format(frfaa.ActionTypeCV))\n", + " print(\"ActionDescription: {}\".format(frfaa.ActionDescription))\n", + " print(\"BeginDateTime: {}\".format(frfaa.BeginDateTime))\n", + " print(\"EndDateTime: {}\".format(frfaa.EndDateTime))\n", + " print(\"MethodName: {}\".format(frfaa.MethodObj.MethodName))\n", + " print(\"MethodDescription: {}\".format(frfaa.MethodObj.MethodDescription))\n", + "except Exception as e:\n", + " print(\"Unable to demo Foreign Key Example: {}\".format(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve Attributes of a Time Series Result using a ResultID\n", + "Use the ResultID (1) from the above result to issue a filtered query." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(odm2api.models.TimeSeriesResults,\n", + " {'FeatureActionID': 1,\n", + " 'FeatureActionObj': ,\n", + " 'ProcessingLevelID': 1,\n", + " 'ResultDateTime': datetime.datetime(2016, 3, 3, 23, 43, 37, 369446),\n", + " 'ResultDateTimeUTCOffset': -7,\n", + " 'ResultID': 1,\n", + " 'ResultTypeCV': u'Time series coverage',\n", + " 'ResultUUID': u'6c769102-e1d4-11e5-8d14-f45c8999816f',\n", + " 'SampledMediumCV': u'Surface Water',\n", + " 'StatusCV': u'Unknown',\n", + " 'TaxonomicClassifierID': None,\n", + " 'UnitsID': 96,\n", + " 'ValidDateTime': None,\n", + " 'ValidDateTimeUTCOffset': None,\n", + " 'ValueCount': 24206,\n", + " 'VariableID': 1,\n", + " '_sa_instance_state': })" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filering on a single ResultID will invariably return a single result; \n", + "# so, get the single element in the returned list\n", + "tsResult = read.getResults(ids=[1])[0]\n", + "\n", + "# Examine the object type and content\n", + "type(tsResult), vars(tsResult)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get a Result and its Attributes\n", + "\n", + "Because all of the objects are returned in a nested form, if you retrieve a result, you can interrogate it to get all of its related attributes. When a Result object is returned, it includes objects that contain information about Variable, Units, ProcessingLevel, and the related Action that created that Result." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------- Example of Retrieving Attributes of a Result -------\n", + "The following are some of the attributes for the Result retrieved: \n", + "ResultID: 1\n", + "ResultTypeCV: Time series coverage\n", + "ValueCount: 24206\n", + "ProcessingLevel: Quality controlled data\n", + "SampledMedium: Surface Water\n", + "Variable: USU36: Temperature\n", + "AggregationStatisticCV: Average\n", + "Units: degree celsius\n", + "SamplingFeatureID: 1\n", + "SamplingFeatureCode: USU-LBR-Mendon\n" + ] + } + ], + "source": [ + "print(\"------- Example of Retrieving Attributes of a Result -------\")\n", + "try:\n", + " firstResult = read.getResults()[0]\n", + " frfa = firstResult.FeatureActionObj\n", + " print(\"The following are some of the attributes for the Result retrieved: \")\n", + " print(\"ResultID: {}\".format(firstResult.ResultID))\n", + " print(\"ResultTypeCV: {}\".format(firstResult.ResultTypeCV))\n", + " print(\"ValueCount: {}\".format(firstResult.ValueCount))\n", + " print(\"ProcessingLevel: {}\".format(firstResult.ProcessingLevelObj.Definition))\n", + " print(\"SampledMedium: {}\".format(firstResult.SampledMediumCV))\n", + " print(\"Variable: {}: {}\".format(firstResult.VariableObj.VariableCode, \n", + " firstResult.VariableObj.VariableNameCV))\n", + " print(\"AggregationStatisticCV: {}\".format(firstResult.AggregationStatisticCV))\n", + " print(\"Units: {}\".format(firstResult.UnitsObj.UnitsName))\n", + " print(\"SamplingFeatureID: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureID))\n", + " print(\"SamplingFeatureCode: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureCode))\n", + "except Exception as e:\n", + " print(\"Unable to demo example of retrieving Attributes of a Result: {}\".format(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------------------------\n", + "\n", + "## Retrieve Time Series Result Values for a given Result\n", + "\n", + "The database contains a single time series result (a time series of water temperature sensor data at a single site). Let's use the **getResultValues()** function to retrieve the time series values for this result by passing in the ResultID. We set the index to `ValueDateTime` for convenience." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ValueIDResultIDDataValueValueDateTimeUTCOffsetCensorCodeCVQualityCodeCVTimeAggregationIntervalTimeAggregationIntervalUnitsID
ValueDateTime
2007-08-16 16:30:001122.20000-7ncUnknown30.0102
2007-08-16 17:00:002122.19833-7ncUnknown30.0102
2007-08-16 17:30:003122.18500-7ncUnknown30.0102
2007-08-16 18:00:004122.03833-7ncUnknown30.0102
2007-08-16 18:30:005121.88167-7ncUnknown30.0102
\n", + "
" + ], + "text/plain": [ + " ValueID ResultID DataValue ValueDateTimeUTCOffset \\\n", + "ValueDateTime \n", + "2007-08-16 16:30:00 1 1 22.20000 -7 \n", + "2007-08-16 17:00:00 2 1 22.19833 -7 \n", + "2007-08-16 17:30:00 3 1 22.18500 -7 \n", + "2007-08-16 18:00:00 4 1 22.03833 -7 \n", + "2007-08-16 18:30:00 5 1 21.88167 -7 \n", + "\n", + " CensorCodeCV QualityCodeCV TimeAggregationInterval \\\n", + "ValueDateTime \n", + "2007-08-16 16:30:00 nc Unknown 30.0 \n", + "2007-08-16 17:00:00 nc Unknown 30.0 \n", + "2007-08-16 17:30:00 nc Unknown 30.0 \n", + "2007-08-16 18:00:00 nc Unknown 30.0 \n", + "2007-08-16 18:30:00 nc Unknown 30.0 \n", + "\n", + " TimeAggregationIntervalUnitsID \n", + "ValueDateTime \n", + "2007-08-16 16:30:00 102 \n", + "2007-08-16 17:00:00 102 \n", + "2007-08-16 17:30:00 102 \n", + "2007-08-16 18:00:00 102 \n", + "2007-08-16 18:30:00 102 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get the values for a particular TimeSeriesResult; a Pandas Dataframe is returned\n", + "tsValues = read.getResultValues(resultids=[1], lowercols=False)\n", + "tsValues.set_index('ValueDateTime', inplace=True)\n", + "tsValues.sort_index(inplace=True)\n", + "\n", + "tsValues.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now plot the time series\n", + "First as a very quick and easy plot using the Pandas Dataframe `plot` method with default settings. Then with fancier matplotlib customizations of the axes and figure size." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tsValues['DataValue'].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12, 4))\n", + "tsValues['DataValue'].plot(ax=ax)\n", + "\n", + "ax.set_ylabel('{} ({})'.format(\n", + " tsResult.VariableObj.VariableNameCV, \n", + " tsResult.UnitsObj.UnitsAbbreviation))\n", + "ax.set_xlabel('')\n", + "\n", + "ax.xaxis.set_minor_locator(mpl.dates.MonthLocator())\n", + "ax.xaxis.set_minor_formatter(mpl.dates.DateFormatter('%b'))\n", + "ax.xaxis.set_major_locator(mpl.dates.YearLocator())\n", + "ax.xaxis.set_major_formatter(mpl.dates.DateFormatter('\\n%Y'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:odm2api_dev]", + "language": "python", + "name": "conda-env-odm2api_dev-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb b/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb new file mode 100644 index 0000000..e0c143d --- /dev/null +++ b/Examples/WaterQualityMeasurements_RetrieveVisualize.ipynb @@ -0,0 +1,1522 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ODM2 API: Retrieve, manipulate and visualize ODM2 water quality measurement-type data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example shows how to use the ODM2 Python API (`odm2api`) to connect to an ODM2 database, retrieve data, and analyze and visualize the data. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n", + "\n", + "This example uses SQLite for the database because it doesn't require a server. However, the ODM2 Python API demonstrated here can alse be used with ODM2 databases implemented in MySQL, PostgreSQL or Microsoft SQL Server.\n", + "\n", + "More details on the ODM2 Python API and its source code and latest development can be found at https://github.com/ODM2/ODM2PythonAPI\n", + "\n", + "[Emilio Mayorga](https://github.com/emiliom/). Last updated 2019-5-10." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adapted from notebook https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/notebooks/ODM2_Example3.ipynb, based in part on earlier code and an ODM2 database from [Jeff Horsburgh's group](http://jeffh.usu.edu) at Utah State University." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mayorga/miniconda/envs/odm2api_dev/lib/python2.7/site-packages/folium/__init__.py:59: UserWarning: This version of folium is the last to support Python 2. Transition to Python 3 to be able to receive updates and fixes. Check out https://python3statement.org/ for more info.\n", + " UserWarning\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from shapely.geometry import Point\n", + "import pandas as pd\n", + "import geopandas as gpd\n", + "import folium\n", + "from folium.plugins import MarkerCluster\n", + "\n", + "import odm2api\n", + "from odm2api.ODMconnection import dbconnection\n", + "import odm2api.services.readService as odm2rs\n", + "from odm2api.models import SamplingFeatures" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(u'0.24.2', u'0.5.0', u'0.8.3')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.__version__, gpd.__version__, folium.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**odm2api version used** to run this notebook:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.7.1+12.g6997f36'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "odm2api.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Connect to the ODM2 SQLite Database\n", + "\n", + "This example uses an ODM2 SQLite database file loaded with water quality sample data from multiple monitoring sites in the [iUTAH](https://iutahepscor.org/) Gradients Along Mountain to Urban Transitions ([GAMUT](http://data.iutahepscor.org/mdf/Data/Gamut_Network/)) water quality monitoring network. Water quality samples have been collected and analyzed for nitrogen, phosphorus, total coliform, E-coli, and some water isotopes. The [database (iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite)](https://github.com/ODM2/ODM2PythonAPI/blob/master/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite) contains [\"measurement\"-type results](http://vocabulary.odm2.org/resulttype/measurement/).\n", + "\n", + "The example database is located in the `data` sub-directory." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign directory paths and SQLite file name\n", + "dbname_sqlite = \"iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite\"\n", + "\n", + "sqlite_pth = os.path.join(\"data\", dbname_sqlite)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Database connection successful!\n" + ] + } + ], + "source": [ + "try:\n", + " session_factory = dbconnection.createConnection('sqlite', sqlite_pth)\n", + " read = odm2rs.ReadODM2(session_factory)\n", + " print(\"Database connection successful!\")\n", + "except Exception as e:\n", + " print(\"Unable to establish connection to the database: \", e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Some Basic Queries on the ODM2 Database\n", + "\n", + "This section shows some examples of how to use the API to run both simple and more advanced queries on the ODM2 database, as well as how to examine the query output in convenient ways thanks to Python tools.\n", + "\n", + "Simple query functions like **getVariables( )** return objects similar to the entities in ODM2, and individual attributes can then be retrieved from the objects returned. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get all Variables\n", + "A simple query with simple output." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NoDataValueSpeciationCVVariableCodeVariableDefinitionVariableNameCVVariableTypeCV_sa_instance_state
VariableID
1-9999.0000000000NTNNoneNitrogen, totalWater quality<sqlalchemy.orm.state.InstanceState object at ...
2-9999.0000000000PTPNonePhosphorus, totalWater quality<sqlalchemy.orm.state.InstanceState object at ...
3-9999.0000000000NNitrateNoneNitrogen, dissolved nitrite (NO2) + nitrate (NO3)Water quality<sqlalchemy.orm.state.InstanceState object at ...
4-9999.0000000000NAmmoniaNoneNitrogen, NH4Water quality<sqlalchemy.orm.state.InstanceState object at ...
5-9999.0000000000PPhosphateNonePhosphorus, orthophosphate dissolvedWater quality<sqlalchemy.orm.state.InstanceState object at ...
6-9999.0000000000Not ApplicableTcoliformNoneColiform, totalWater quality<sqlalchemy.orm.state.InstanceState object at ...
7-9999.0000000000Not ApplicableE-ColiNoneE-coliWater quality<sqlalchemy.orm.state.InstanceState object at ...
8-9999.0000000000CDOCNoneCarbon, dissolved organicWater quality<sqlalchemy.orm.state.InstanceState object at ...
9-9999.0000000000NTDNNoneNitrogen, total dissolvedWater quality<sqlalchemy.orm.state.InstanceState object at ...
10-9999.0000000000Not ApplicableAbs254NoneAbsorbanceWater quality<sqlalchemy.orm.state.InstanceState object at ...
\n", + "
" + ], + "text/plain": [ + " NoDataValue SpeciationCV VariableCode VariableDefinition \\\n", + "VariableID \n", + "1 -9999.0000000000 N TN None \n", + "2 -9999.0000000000 P TP None \n", + "3 -9999.0000000000 N Nitrate None \n", + "4 -9999.0000000000 N Ammonia None \n", + "5 -9999.0000000000 P Phosphate None \n", + "6 -9999.0000000000 Not Applicable Tcoliform None \n", + "7 -9999.0000000000 Not Applicable E-Coli None \n", + "8 -9999.0000000000 C DOC None \n", + "9 -9999.0000000000 N TDN None \n", + "10 -9999.0000000000 Not Applicable Abs254 None \n", + "\n", + " VariableNameCV VariableTypeCV \\\n", + "VariableID \n", + "1 Nitrogen, total Water quality \n", + "2 Phosphorus, total Water quality \n", + "3 Nitrogen, dissolved nitrite (NO2) + nitrate (NO3) Water quality \n", + "4 Nitrogen, NH4 Water quality \n", + "5 Phosphorus, orthophosphate dissolved Water quality \n", + "6 Coliform, total Water quality \n", + "7 E-coli Water quality \n", + "8 Carbon, dissolved organic Water quality \n", + "9 Nitrogen, total dissolved Water quality \n", + "10 Absorbance Water quality \n", + "\n", + " _sa_instance_state \n", + "VariableID \n", + "1 \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PersonFirstNamePersonIDPersonLastNamePersonMiddleName_sa_instance_state
0Nancy1Mesner<sqlalchemy.orm.state.InstanceState object at ...
1Dane2Brophy<sqlalchemy.orm.state.InstanceState object at ...
2Ben3Rider<sqlalchemy.orm.state.InstanceState object at ...
3Michelle4Baker<sqlalchemy.orm.state.InstanceState object at ...
4Erin5Jones<sqlalchemy.orm.state.InstanceState object at ...
\n", + "" + ], + "text/plain": [ + " PersonFirstName PersonID PersonLastName PersonMiddleName \\\n", + "0 Nancy 1 Mesner \n", + "1 Dane 2 Brophy \n", + "2 Ben 3 Rider \n", + "3 Michelle 4 Baker \n", + "4 Erin 5 Jones \n", + "\n", + " _sa_instance_state \n", + "0 \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ElevationDatumCVElevation_mFeatureGeometryWKTLatitudeLongitudeSamplingFeatureCodeSamplingFeatureDescriptionSamplingFeatureGeotypeCVSamplingFeatureIDSamplingFeatureNameSamplingFeatureTypeCVSamplingFeatureUUIDSiteTypeCVSpatialReferenceID_sa_instance_stategeometry
0EGM961356.0None40.745078-111.854449RB_1300ENoneNone1Red Butte Creek at 1300E (downstream of spring)Site0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2Stream1<sqlalchemy.orm.state.InstanceState object at ...POINT (-111.854449 40.745078)
1EGM961356.0None40.745106-111.854389RB_1300ESpringNoneNone2Spring that enters Red Butte Creek at 1300ESite9848BBFE-EA3F-4918-A324-13E8EDE5381CSpring1<sqlalchemy.orm.state.InstanceState object at ...POINT (-111.854389 40.745106)
2EGM961289.0None40.741583-111.917667RB_900W_BANoneNone3Red Butte Creek terminus at Jordan River at 13...Site688017BC-9E02-4444-A21D-270366BE2348Stream1<sqlalchemy.orm.state.InstanceState object at ...POINT (-111.917667 40.741583)
3EGM961519.0None40.766134-111.826530RB_AmphitheaterNoneNone4Red Butte Creek below Red Butte Garden Amphith...Site9CFE685B-5CDA-4E38-98D9-406D645C7D21Stream1<sqlalchemy.orm.state.InstanceState object at ...POINT (-111.82653 40.766134)
4EGM961648.0None40.779602-111.806669RB_ARBR_AANoneNone5Red Butte Creek above Red Butte Reservoir Adan...Site98C7F63A-FDFB-4898-87C6-5AA8EC34D1E4Stream1<sqlalchemy.orm.state.InstanceState object at ...POINT (-111.806669 40.779602)
\n", + "" + ], + "text/plain": [ + " ElevationDatumCV Elevation_m FeatureGeometryWKT Latitude Longitude \\\n", + "0 EGM96 1356.0 None 40.745078 -111.854449 \n", + "1 EGM96 1356.0 None 40.745106 -111.854389 \n", + "2 EGM96 1289.0 None 40.741583 -111.917667 \n", + "3 EGM96 1519.0 None 40.766134 -111.826530 \n", + "4 EGM96 1648.0 None 40.779602 -111.806669 \n", + "\n", + " SamplingFeatureCode SamplingFeatureDescription SamplingFeatureGeotypeCV \\\n", + "0 RB_1300E None None \n", + "1 RB_1300ESpring None None \n", + "2 RB_900W_BA None None \n", + "3 RB_Amphitheater None None \n", + "4 RB_ARBR_AA None None \n", + "\n", + " SamplingFeatureID SamplingFeatureName \\\n", + "0 1 Red Butte Creek at 1300E (downstream of spring) \n", + "1 2 Spring that enters Red Butte Creek at 1300E \n", + "2 3 Red Butte Creek terminus at Jordan River at 13... \n", + "3 4 Red Butte Creek below Red Butte Garden Amphith... \n", + "4 5 Red Butte Creek above Red Butte Reservoir Adan... \n", + "\n", + " SamplingFeatureTypeCV SamplingFeatureUUID SiteTypeCV \\\n", + "0 Site 0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2 Stream \n", + "1 Site 9848BBFE-EA3F-4918-A324-13E8EDE5381C Spring \n", + "2 Site 688017BC-9E02-4444-A21D-270366BE2348 Stream \n", + "3 Site 9CFE685B-5CDA-4E38-98D9-406D645C7D21 Stream \n", + "4 Site 98C7F63A-FDFB-4898-87C6-5AA8EC34D1E4 Stream \n", + "\n", + " SpatialReferenceID _sa_instance_state \\\n", + "0 1 " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# A trivial but easy-to-generate GeoPandas plot\n", + "gdf.plot();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A site has a `SiteTypeCV`. Let's examine the site type distribution, and use that information to create a new GeoDataFrame column to specify a map marker color by `SiteTypeCV`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Stream 24\n", + "Spring 1\n", + "Name: SiteTypeCV, dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf['SiteTypeCV'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "gdf[\"color\"] = gdf.apply(lambda feat: 'green' if feat['SiteTypeCV'] == 'Stream' else 'red', axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: While the database holds a copy of the **ODM2 Controlled Vocabularies**, the complete description of each CV term is available from a web request to the CV API at http://vocabulary.odm2.org. Want to know more about how a \"spring\" is defined? Here's one simple way, using `Pandas` to access and parse the CSV web service response." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
termnamedefinitioncategoryprovenanceprovenance_urinote
0springSpringA location at which the water table intersects...Spring SitesAdapted from USGS Site Types.NaNhttp://wdr.water.usgs.gov/nwisgmap/help/sitety...
\n", + "
" + ], + "text/plain": [ + " term name definition \\\n", + "0 spring Spring A location at which the water table intersects... \n", + "\n", + " category provenance provenance_uri \\\n", + "0 Spring Sites Adapted from USGS Site Types. NaN \n", + "\n", + " note \n", + "0 http://wdr.water.usgs.gov/nwisgmap/help/sitety... " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sitetype = 'spring'\n", + "pd.read_csv(\"http://vocabulary.odm2.org/api/v1/sitetype/{}/?format=csv\".format(sitetype))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Now we'll create an interactive and helpful `Folium` map of the sites.** This map features:\n", + "- Automatic panning to the location of the sites (no hard wiring, except for the zoom scale), based on GeoPandas functionality and information from the ODM2 Site Sampling Features\n", + "- Color coding by `SiteTypeCV` \n", + "- Marker clustering\n", + "- Simple marker pop ups with content from the ODM2 Site Sampling Features" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = gdf.unary_union.centroid\n", + "m = folium.Map(location=[c.y, c.x], tiles='CartoDB positron', zoom_start=11)\n", + "\n", + "marker_cluster = MarkerCluster().add_to(m)\n", + "for idx, feature in gdf.iterrows():\n", + " folium.Marker(location=[feature.geometry.y, feature.geometry.x], \n", + " icon=folium.Icon(color=feature['color']),\n", + " popup=\"{0} ({1}): {2}\".format(\n", + " feature['SamplingFeatureCode'], feature['SiteTypeCV'], \n", + " feature['SamplingFeatureName'])\n", + " ).add_to(marker_cluster)\n", + "\n", + " \n", + "# Done with setup. Now render the map\n", + "m" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add a new Sampling Feature\n", + "Just to llustrate how to add a new entry. We won't \"commit\" (save) the sampling feature to the database." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New sampling feature created, but not saved to database.\n", + "\n", + "\n" + ] + } + ], + "source": [ + "sitesf0 = siteFeatures[0]\n", + "\n", + "try:\n", + " newsf = SamplingFeatures()\n", + " session = session_factory.getSession()\n", + " newsf.FeatureGeometryWKT = \"POINT(-111.946 41.718)\"\n", + " newsf.Elevation_m = 100\n", + " newsf.ElevationDatumCV = sitesf0.ElevationDatumCV\n", + " newsf.SamplingFeatureCode = \"TestSF\"\n", + " newsf.SamplingFeatureDescription = \"this is a test to add a sampling feature\"\n", + " newsf.SamplingFeatureGeotypeCV = \"Point\"\n", + " newsf.SamplingFeatureTypeCV = sitesf0.SamplingFeatureTypeCV\n", + " newsf.SamplingFeatureUUID = sitesf0.SamplingFeatureUUID+\"2\"\n", + " session.add(newsf)\n", + " # To save the new sampling feature, do session.commit()\n", + " print(\"New sampling feature created, but not saved to database.\\n\")\n", + " print(newsf)\n", + "except Exception as e :\n", + " print(\"error adding a sampling feature: {}\".format(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get Objects and Related Objects from the Database (SamplingFeatures example)\n", + "\n", + "This code shows some examples of how objects and related objects can be retrieved using the API. In the following, we use the **getSamplingFeatures( )** function to return a particular sampling feature by passing in its SamplingFeatureCode. This function returns a list of SamplingFeature objects, so just get the first one in the returned list." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "odm2api.models.Sites" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get the SamplingFeature object for a particular SamplingFeature by passing its SamplingFeatureCode\n", + "sf = read.getSamplingFeatures(codes=['RB_1300E'])[0]\n", + "type(sf)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ElevationDatumCV': u'EGM96',\n", + " 'Elevation_m': 1356.0,\n", + " 'FeatureGeometryWKT': None,\n", + " 'Latitude': 40.745078,\n", + " 'Longitude': -111.854449,\n", + " 'SamplingFeatureCode': u'RB_1300E',\n", + " 'SamplingFeatureDescription': None,\n", + " 'SamplingFeatureGeotypeCV': None,\n", + " 'SamplingFeatureID': 1,\n", + " 'SamplingFeatureName': u'Red Butte Creek at 1300E (downstream of spring)',\n", + " 'SamplingFeatureTypeCV': u'Site',\n", + " 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n", + " 'SiteTypeCV': u'Stream',\n", + " 'SpatialReferenceID': 1,\n", + " '_sa_instance_state': }" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Simple way to examine the content (properties) of a Python object, as if it were a dictionary\n", + "vars(sf)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also drill down and get objects linked by foreign keys. The API returns related objects in a nested hierarchy so they can be interrogated in an object oriented way. So, if I use the **getResults( )** function to return a Result from the database (e.g., a \"Measurement\" Result), I also get the associated Action that created that Result (e.g., a \"Specimen analysis\" Action)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('The FeatureAction object for the Result is: ', )\n", + "('The Action object for the Result is: ', )\n", + "\n", + "The following are some of the attributes for the Action that created the Result: \n", + "ActionTypeCV: Specimen analysis\n", + "ActionDescription: None\n", + "BeginDateTime: 2014-10-30 00:00:00\n", + "EndDateTime: None\n", + "MethodName: Astoria Total Phosphorus\n", + "MethodDescription: Determination of total phosphorus by persulphate oxidation digestion and ascorbic acid method\n" + ] + } + ], + "source": [ + "try:\n", + " # Call getResults, but return only the first Result\n", + " firstResult = read.getResults()[0]\n", + " frfa = firstResult.FeatureActionObj\n", + " frfaa = firstResult.FeatureActionObj.ActionObj\n", + " print(\"The FeatureAction object for the Result is: \", frfa)\n", + " print(\"The Action object for the Result is: \", frfaa)\n", + " \n", + " # Print some Action attributes in a more human readable form\n", + " print(\"\\nThe following are some of the attributes for the Action that created the Result: \")\n", + " print(\"ActionTypeCV: {}\".format(frfaa.ActionTypeCV))\n", + " print(\"ActionDescription: {}\".format(frfaa.ActionDescription))\n", + " print(\"BeginDateTime: {}\".format(frfaa.BeginDateTime))\n", + " print(\"EndDateTime: {}\".format(frfaa.EndDateTime))\n", + " print(\"MethodName: {}\".format(frfaa.MethodObj.MethodName))\n", + " print(\"MethodDescription: {}\".format(frfaa.MethodObj.MethodDescription))\n", + "except Exception as e:\n", + " print(\"Unable to demo Foreign Key Example: {}\".format(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Get a Result and its Attributes\n", + "\n", + "Because all of the objects are returned in a nested form, if you retrieve a result, you can interrogate it to get all of its related attributes. When a Result object is returned, it includes objects that contain information about Variable, Units, ProcessingLevel, and the related Action that created that Result." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------- Example of Retrieving Attributes of a Result -------\n", + "The following are some of the attributes for the Result retrieved: \n", + "ResultID: 1\n", + "ResultTypeCV: Measurement\n", + "ValueCount: 1\n", + "ProcessingLevel: Raw Data\n", + "SampledMedium: Liquid aqueous\n", + "Variable: TP: Phosphorus, total\n", + "Units: milligrams per liter\n", + "SamplingFeatureID: 26\n", + "SamplingFeatureCode: 3\n" + ] + } + ], + "source": [ + "print(\"------- Example of Retrieving Attributes of a Result -------\")\n", + "try:\n", + " firstResult = read.getResults()[0]\n", + " frfa = firstResult.FeatureActionObj\n", + " print(\"The following are some of the attributes for the Result retrieved: \")\n", + " print(\"ResultID: {}\".format(firstResult.ResultID))\n", + " print(\"ResultTypeCV: {}\".format(firstResult.ResultTypeCV))\n", + " print(\"ValueCount: {}\".format(firstResult.ValueCount))\n", + " print(\"ProcessingLevel: {}\".format(firstResult.ProcessingLevelObj.Definition))\n", + " print(\"SampledMedium: {}\".format(firstResult.SampledMediumCV))\n", + " print(\"Variable: {}: {}\".format(firstResult.VariableObj.VariableCode, \n", + " firstResult.VariableObj.VariableNameCV))\n", + " print(\"Units: {}\".format(firstResult.UnitsObj.UnitsName))\n", + " print(\"SamplingFeatureID: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureID))\n", + " print(\"SamplingFeatureCode: {}\".format(frfa.SamplingFeatureObj.SamplingFeatureCode))\n", + "except Exception as e:\n", + " print(\"Unable to demo example of retrieving Attributes of a Result: {}\".format(e))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last block of code returns a particular Measurement Result. From that I can get the SamplingFeaureID (in this case 26) for the Specimen from which the Result was generated. But, if I want to figure out which Site the Specimen was collected at, I need to query the database to get the related Site SamplingFeature. I can use **getRelatedSamplingFeatures( )** for this. Once I've got the SamplingFeature for the Site, I could get the rest of the SamplingFeature attributes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve the \"Related\" Site at which a Specimen was collected" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Pass the Sampling Feature ID of the specimen, and the relationship type\n", + "relatedSite = read.getRelatedSamplingFeatures(sfid=26, relationshiptype='Was Collected at')[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ElevationDatumCV': u'EGM96',\n", + " 'Elevation_m': 1356.0,\n", + " 'FeatureGeometryWKT': None,\n", + " 'Latitude': 40.745078,\n", + " 'Longitude': -111.854449,\n", + " 'SamplingFeatureCode': u'RB_1300E',\n", + " 'SamplingFeatureDescription': None,\n", + " 'SamplingFeatureGeotypeCV': None,\n", + " 'SamplingFeatureID': 1,\n", + " 'SamplingFeatureName': u'Red Butte Creek at 1300E (downstream of spring)',\n", + " 'SamplingFeatureTypeCV': u'Site',\n", + " 'SamplingFeatureUUID': u'0DDE8EF6-EC2F-42C0-AB50-20C6C02E89B2',\n", + " 'SiteTypeCV': u'Stream',\n", + " 'SpatialReferenceID': 1,\n", + " '_sa_instance_state': }" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vars(relatedSite)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------------------------\n", + "\n", + "## Return Results and Data Values for a Particular Site/Variable\n", + "\n", + "From the list of Variables returned above and the information about the SamplingFeature I queried above, I know that VariableID = 2 for Total Phosphorus and SiteID = 1 for the Red Butte Creek site at 1300E. I can use the **getResults( )** function to get all of the Total Phosphorus results for this site by passing in the VariableID and the SiteID." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "siteID = 1 # Red Butte Creek at 1300 E (obtained from the getRelatedSamplingFeatures query)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "18" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v = variables_df[variables_df['VariableCode'] == 'TP']\n", + "variableID = v.index[0]\n", + "\n", + "results = read.getResults(siteid=siteID, variableid=variableID, restype=\"Measurement\")\n", + "# Get the list of ResultIDs so I can retrieve the data values associated with all of the results\n", + "resultIDList = [x.ResultID for x in results]\n", + "len(resultIDList)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve the Result (Data) Values, Then Create a Quick Time Series Plot of the Data\n", + "\n", + "Now I can retrieve all of the data values associated with the list of Results I just retrieved. In ODM2, water chemistry measurements are stored as \"Measurement\" results. Each \"Measurement\" Result has a single data value associated with it. So, for convenience, the **getResultValues( )** function allows you to pass in a list of ResultIDs so you can get the data values for all of them back in a Pandas data frame object, which is easier to work with. Once I've got the data in a Pandas data frame object, I can use the **plot( )** function directly on the data frame to create a quick visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ValueIDResultIDDataValueValueDateTimeValueDateTimeUTCOffset
0110.01002015-10-27 13:26:24-7
110010.01002015-11-17 13:55:12-7
2109100.05742015-05-12 14:24:00-7
310100.05742015-06-18 12:43:12-7
4198990.04242015-10-27 13:55:12-7
\n", + "
" + ], + "text/plain": [ + " ValueID ResultID DataValue ValueDateTime ValueDateTimeUTCOffset\n", + "0 1 1 0.0100 2015-10-27 13:26:24 -7\n", + "1 100 1 0.0100 2015-11-17 13:55:12 -7\n", + "2 109 10 0.0574 2015-05-12 14:24:00 -7\n", + "3 10 10 0.0574 2015-06-18 12:43:12 -7\n", + "4 198 99 0.0424 2015-10-27 13:55:12 -7" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get all of the data values for the Results in the list created above\n", + "# Call getResultValues, which returns a Pandas Data Frame with the data\n", + "resultValues = read.getResultValues(resultids=resultIDList, lowercols=False)\n", + "resultValues.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the time sequence of Measurement Result Values \n", + "ax = resultValues.plot(x='ValueDateTime', y='DataValue', title=relatedSite.SamplingFeatureName,\n", + " kind='line', use_index=True, linestyle='solid', style='o')\n", + "ax.set_ylabel(\"{0} ({1})\".format(results[0].VariableObj.VariableNameCV, \n", + " results[0].UnitsObj.UnitsAbbreviation))\n", + "ax.set_xlabel('Date/Time')\n", + "ax.legend().set_visible(False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### End with a fancier plot, facilitated via a function\n", + "\n", + "If I'm going to reuse a series of steps, it's always helpful to write little generic functions that can be called to quickly and consistently get what we need. To conclude this demo, here's one such function that encapsulates the `VariableID`, `getResults` and `getResultValues` queries we showed above. Then we leverage it to create a nice 2-variable (2-axis) plot of TP and TN vs time, and conclude with a reminder that we have ready access to related metadata about analytical lab methods and such." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def get_results_and_values(siteid, variablecode):\n", + " v = variables_df[variables_df['VariableCode'] == variablecode]\n", + " variableID = v.index[0]\n", + " \n", + " results = read.getResults(siteid=siteid, variableid=variableID, restype=\"Measurement\")\n", + " resultIDList = [x.ResultID for x in results]\n", + " resultValues = read.getResultValues(resultids=resultIDList, lowercols=False)\n", + " \n", + " return resultValues, results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fancy plotting, leveraging the `Pandas` plot method and `matplotlib`." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot figure and axis set up\n", + "f, ax = plt.subplots(1, figsize=(13, 6))\n", + "\n", + "# First plot (left axis)\n", + "VariableCode = 'TP'\n", + "resultValues_TP, results_TP = get_results_and_values(siteID, VariableCode)\n", + "resultValues_TP.plot(x='ValueDateTime', y='DataValue', label=VariableCode, \n", + " style='o-', kind='line', ax=ax)\n", + "ax.set_ylabel(\"{0}: {1} ({2})\".format(VariableCode, results_TP[0].VariableObj.VariableNameCV, \n", + " results_TP[0].UnitsObj.UnitsAbbreviation))\n", + "\n", + "# Second plot (right axis)\n", + "VariableCode = 'TN'\n", + "resultValues_TN, results_TN = get_results_and_values(siteID, VariableCode)\n", + "resultValues_TN.plot(x='ValueDateTime', y='DataValue', label=VariableCode, \n", + " style='^-', kind='line', ax=ax,\n", + " secondary_y=True)\n", + "ax.right_ax.set_ylabel(\"{0}: {1} ({2})\".format(VariableCode, results_TN[0].VariableObj.VariableNameCV, \n", + " results_TN[0].UnitsObj.UnitsAbbreviation))\n", + "\n", + "# Tweak the figure\n", + "ax.legend(loc='upper left')\n", + "ax.right_ax.legend(loc='upper right')\n", + "\n", + "ax.grid(True)\n", + "ax.set_xlabel('')\n", + "ax.set_title(relatedSite.SamplingFeatureName);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's show some useful metadata. Use the `Results` records and their relationship to `Actions` (via `FeatureActions`) to **extract and print out the Specimen Analysis methods used for TN and TP**. Or at least for the *first* result for each of the two variables; methods may have varied over time, but the specific method associated with each result is stored in ODM2 and available." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TP METHOD: Astoria Total Phosphorus (Determination of total phosphorus by persulphate oxidation digestion and ascorbic acid method)\n", + "TN METHOD: Astoria Total Nitrogen (Determination of total Nitrogen by persulphate oxidation digestion and cadmium reduction method)\n" + ] + } + ], + "source": [ + "results_faam = lambda results, i: results[i].FeatureActionObj.ActionObj.MethodObj\n", + "\n", + "print(\"TP METHOD: {0} ({1})\".format(results_faam(results_TP, 0).MethodName,\n", + " results_faam(results_TP, 0).MethodDescription))\n", + "print(\"TN METHOD: {0} ({1})\".format(results_faam(results_TN, 0).MethodName,\n", + " results_faam(results_TN, 0).MethodDescription))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:odm2api_dev]", + "language": "python", + "name": "conda-env-odm2api_dev-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Examples/clientenvironment.yml b/Examples/clientenvironment.yml new file mode 100644 index 0000000..7999ae2 --- /dev/null +++ b/Examples/clientenvironment.yml @@ -0,0 +1,16 @@ +name: odm2client +channels: +- conda-forge +dependencies: +- python=2.7 +- odm2api +- yodatools +- requests +- scipy +- geopandas +- gdal +- folium +# Jupyter notebook +- ipykernel +- jupyter +- nb_conda_kernels diff --git a/Examples/data/README.md b/Examples/data/README.md new file mode 100644 index 0000000..2a89482 --- /dev/null +++ b/Examples/data/README.md @@ -0,0 +1,4 @@ +## Original source of each of the sample ODM2 databases: + +- `USU_LittleBearRiver_timeseriesresults_ODM2.sqlite`: https://github.com/ODM2/WOFpy/blob/master/test/odm2/ODM2.sqlite +- `iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite`: https://github.com/BiG-CZ/wshp2017_tutorial_content/blob/master/data/expectedoutput/ODM2_Example2.sqlite diff --git a/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite b/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite new file mode 100644 index 0000000..e15ecf9 Binary files /dev/null and b/Examples/data/USU_LittleBearRiver_timeseriesresults_ODM2.sqlite differ diff --git a/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite b/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite new file mode 100644 index 0000000..bfda761 Binary files /dev/null and b/Examples/data/iUTAHGAMUT_waterquality_measurementresults_ODM2.sqlite differ diff --git a/docs/source/contribute.rst b/docs/source/contribute.rst index 25103c0..44d69ca 100644 --- a/docs/source/contribute.rst +++ b/docs/source/contribute.rst @@ -1,11 +1,55 @@ -Contribute to Documentation +Contributing ============================ +You can help with ODM2 Python API by contributing code, helping with the documentation, or engaging the team via `GitHub issues `_ (questions, solutions, etc). + + +Install the development version from GitHub +-------------------------------------------- + +The latest development version is found in the ``development`` branch of the github repository. We follow the `Gitflow workflow `__ for development. + +1. Download both ``requirements.txt`` and ``requirements-dev.txt``. + + .. code-block:: bash + + wget https://raw.githubusercontent.com/ODM2/ODM2PythonAPI/master/requirements.txt + wget https://raw.githubusercontent.com/ODM2/ODM2PythonAPI/master/requirements-dev.txt + +2. Create conda environment ``odm2api_dev`` from the two ``requirements*`` text files. + + .. code-block:: bash + + conda create -n odm2api_dev -c conda-forge python=2.7 --file requirements.txt --file requirements-dev.txt + +3. Activate conda environment. + - MacOSX/Linux: + + .. code-block:: bash + + source activate odm2api_dev + + - Windows: + + .. code-block:: bash + + activate odm2api_dev + +4. Install the latest commit from the development branch + + .. code-block:: bash + + pip install git+https://github.com/ODM2/ODM2PythonAPI.git@development#egg=odm2api + + +Contribute to documentation +---------------------------------- + This guide is a reference on how to contribute to ODM2 Documentation effort for the many `ODM2 Software Ecosystem `__. Conventions ------------ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ There are a few conventions that should be followed when writing docstrings within the code: @@ -30,7 +74,7 @@ Please add any additional conventions that you think should be in place within `the github issue #106 `__. Pull requests -------------- +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Once changes has been in place within your forked copy of the repository you are working on, please create a pull request to add your contribution diff --git a/docs/source/getstarted.rst b/docs/source/getstarted.rst new file mode 100644 index 0000000..7584f49 --- /dev/null +++ b/docs/source/getstarted.rst @@ -0,0 +1,113 @@ +Get Started +============ + + +Install the latest release with conda +------------------------------------- + +conda +^^^^^ + +The easiest and most reliable way to install the ODM2 Python API +(``odm2api``) is using the `Conda package management +system `__ via either +`Anaconda `__ or +`Miniconda `__. To start using +conda (if it's not your system default), add conda to the PATH; on +OS X and Linux, it's something like +``export PATH=$HOME/miniconda3/bin:$PATH``, but the exact path may vary. + +To activate a conda environment, say, "myenv": + +.. code-block:: bash + + activate myenv # On Windows + source activate myenv # On MacOSX or Linux + +**Note:** ``odm2api`` currently is only tested on Python 2.7. Some +changes have been made to support Python 3.x, but they haven't been +tested thoroughly. + +Install the conda package +^^^^^^^^^^^^^^^^^^^^^^^^^ + +The `latest release `_ is available +as a package on the `conda-forge anaconda.org channel `_ +for all major OS platforms (linux, OS X, win32/win64). To install it on +an existing conda environment: + +:: + + conda install -c conda-forge odm2api + +All dependencies are installed, including Pandas and its dependencies +(numpy, etc). + +To create a new environment "myenv" with the ``odm2api`` package: + +:: + + conda create -n myenv -c conda-forge python=2.7 odm2api + +Sample Jupyter notebooks +------------------------ + +These two notebooks are complete, extended examples that illustrate reading from ODM2 databases and using the resulting data and metadata. They use SQLite ODM2 file databases that can be `downloaded here `_. +A conda environment to run these notebooks can be created with the conda environment file +`clientenvironment.yml `_. + +1. `WaterQualityMeasurements_RetrieveVisualize.ipynb `_ + +2. `TimeSeries_RetrieveVisualize.ipynb `_ + +Code examples +------------- + +Connecting to an ODM2 database +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Connect to an ODM2 database and open the connection for reading. + +.. code-block:: python + + from odm2api.ODMconnection import dbconnection + import odm2api.services.readService as odm2rs + + # ----------------------------------------------------- + # 1. A SQLite file-based connection + session_factory = dbconnection.createConnection('sqlite', + '/myfilepath/odm2db.sqlite') + read = odm2rs.ReadODM2(session_factory) + + # ----------------------------------------------------- + # 2. A server-based database system connection + db_credentials = { + 'address': 'ip-or-domainname', + 'db': 'dbname', + 'user': 'dbuser', + 'password': 'password' + } + session_factory = dbconnection.createConnection('postgresql', + **db_credentials) + read = odm2rs.ReadODM2(session_factory) + + +Updating an entity (table) +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The `update services `_ +have not been fleshed out at this time, for the most part. However, updates can be easily +accomplished by reusing the connection setup at the start of an odm2api session, +then constructing and issuing a direct ``SQL UPDATE`` statement, like this: + +.. code-block:: python + + from odm2api.ODMconnection import dbconnection + + session_factory = dbconnection.createConnection('postgresql', + **db_credentials) + DBSession = session_factory.getSession() + + sq_str = " UPDATE mytable SET variablecode = 'xyz' WHERE variablecode = 'abc' " + DBSession.execute(sql_str) + DBSession.commit() diff --git a/docs/source/index.rst b/docs/source/index.rst index c0fc138..425927d 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,26 +1,26 @@ -ODM2 Python API -=============== +ODM2 Python API (odm2api) +========================= -A Python-based application programmer's interface for the `Observations Data Model 2 (ODM2) `__. +A Python-based application programmer's interface for the `Observations Data Model 2 (ODM2) `__. Development of ``odm2api`` is done at ``_. + +Contents +-------- .. toctree:: :maxdepth: 2 - :caption: Contents: - installing - modules + getstarted odm2models - credits + modules contribute + credits -Indices and tables -================== +Indices and Search +----------------- .. toctree:: :maxdepth: 2 - models - * :ref:`genindex` * :ref:`modindex` * :ref:`search` diff --git a/docs/source/installing.rst b/docs/source/installing.rst deleted file mode 100644 index 4064f0f..0000000 --- a/docs/source/installing.rst +++ /dev/null @@ -1,81 +0,0 @@ -Installation -============ - -The easiest and most reliable way to install the ODM2 Python API -(``odm2api``) is using the `Conda package management -system `__ via either -`Anaconda `__ or -`Miniconda `__. To start using -conda (if it's not your system default), add conda to the PATH; on -OS X and Linux, it's something like -``export PATH=$HOME/miniconda3/bin:$PATH``, but the exact path may vary. - -To activate a conda environment, say, "myenv": - -.. code-block:: bash - - activate myenv # On Windows - source activate myenv # On MacOSX or Linux - -**Note:** ``odm2api`` currently is only tested on Python 2.7. Some -changes have been made to support Python 3.x, but they haven't been -tested thoroughly. - -Latest release, from conda-forge anaconda.org channel ----------------------------------------------- - -The `latest release `_ is available -on the `conda-forge anaconda.org channel `_ -for all major OS platforms (linux, OS X, win32/win64). To install it on -an existing conda environment: - -:: - - conda install -c conda-forge odm2api - -All dependencies are installed, including Pandas and its dependencies -(numpy, etc). - -To create a new environment "myenv" with the ``odm2api`` package: - -:: - - conda create -n myenv -c conda-forge python=2.7 odm2api - - -Installing the development version from the ``development`` branch on github ----------------------------------- - -Note: We follow the `Gitflow workflow `__ for development. - -1. Download both ``requirements.txt`` and ``requirements-dev.txt``. - - .. code-block:: bash - - wget https://raw.githubusercontent.com/ODM2/ODM2PythonAPI/master/requirements.txt - wget https://raw.githubusercontent.com/ODM2/ODM2PythonAPI/master/requirements-dev.txt - -2. Create conda environment ``odm2api_dev`` from the two ``requirements*`` text files. - - .. code-block:: bash - - conda create -n odm2api_dev -c conda-forge python=2.7 --file requirements.txt --file requirements-dev.txt - -3. Activate conda environment. - - MacOSX/Linux: - - .. code-block:: bash - - source activate odm2api_dev - - - Windows: - - .. code-block:: bash - - activate odm2api_dev - -4. Install the latest commit from the development branch - - .. code-block:: bash - - pip install git+https://github.com/ODM2/ODM2PythonAPI.git@development#egg=odm2api diff --git a/docs/source/models.rst b/docs/source/models.rst deleted file mode 100644 index aa23167..0000000 --- a/docs/source/models.rst +++ /dev/null @@ -1,27 +0,0 @@ -ODM2 Models Index -================== - -ODM2 is organized with a "core" schema and multiple "extension" schemas that -extend the functionality of the core. The following sections cover some overarching concepts -for ODM2 and then focus on specific entities within the ODM2 Core schema and ODM2's extension schemas. - -ODM2Core Entities ------------------- - -The following are entities in the `ODM2 Core Schema `__: - -.. autosummary:: - - odm2api.models.Actions - odm2api.models.DataSets - odm2api.models.FeatureActions - odm2api.models.Methods - odm2api.models.Organizations - odm2api.models.People - odm2api.models.ProcessingLevels - odm2api.models.RelatedActions - odm2api.models.Results - odm2api.models.SamplingFeatures - odm2api.models.TaxonomicClassifiers - odm2api.models.Units - odm2api.models.Variables \ No newline at end of file diff --git a/docs/source/odm2models.rst b/docs/source/odm2models.rst index 1e3dbff..d6b8530 100644 --- a/docs/source/odm2models.rst +++ b/docs/source/odm2models.rst @@ -1,6 +1,39 @@ ODM2 Models =========== +ODM2 is organized with a "core" schema and multiple "extension" schemas that +extend the functionality of the core. The following sections cover some overarching concepts +for ODM2 and then focus on specific entities within the ODM2 Core schema and ODM2's extension schemas. + +ODM2Core entities +------------------ + +The following are entities in the `ODM2 Core Schema `__: + +.. autosummary:: + + odm2api.models.ActionBy + odm2api.models.Actions + odm2api.models.Affiliations + odm2api.models.DataSets + odm2api.models.FeatureActions + odm2api.models.Methods + odm2api.models.Organizations + odm2api.models.People + odm2api.models.ProcessingLevels + odm2api.models.RelatedActions + odm2api.models.Results + odm2api.models.SamplingFeatures + odm2api.models.TaxonomicClassifiers + odm2api.models.Units + odm2api.models.Variables + + +All ODM2 models +---------------- + +API descriptions for `all ODM2 models (entities) `_. + .. automodule:: odm2api.models :members: :undoc-members: