We're sorry but this page doesn't work properly without JavaScript enabled. Please enable it to continue.
Feedback

pygeoapi project status 2022

00:00

Formal Metadata

Title
pygeoapi project status 2022
Title of Series
Number of Parts
351
Author
Contributors
License
CC Attribution 3.0 Unported:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
Language
Production Year2022

Content Metadata

Subject Area
Genre
Abstract
pygeoapi is an OGC API Reference Implementation. Implemented in Python, pygeoapi supports numerous OGC APIs via a core agnostic API, different web frameworks (Flask, Starlette, Django) and a fully integrated OpenAPI capability. Lightweight, easy to deploy and cloud-ready, pygeoapi's architecture facilitates publishing datasets and processes from multiple sources. The project also provides an extensible plugin framework, enabling developers to implement custom data adapters, filters and processes to meet their specific requirements and workflows. pygeoapi also supports the STAC specification in support of static data publishing. pygeoapi has a significant install base around the world, with numerous projects in academia, government and industry deployments. The project is also an OGC API Reference Implementation, lowering the barrier to publishing geospatial data for all users. This presentation will provide an update on the current status, latest developments in the project, including new core features and plugins. In addition, the presentation will highlight key projects using pygeoapi for geospatial data discovery, access and visualization.
Keywords
202
Thumbnail
1:16:05
226
242
Content (media)Core dumpWeb browserCondition numberDefault (computer science)Software frameworkMetadataPlug-in (computing)Component-based software engineeringDiagramClient (computing)Internet service providerMenu (computing)Stochastic processImplementationCore dumpWeb 2.0Projective planeOpen setComputer architectureDiagramTime zoneOpen sourceSoftware frameworkSelf-organizationAbstractionTerm (mathematics)Server (computing)Configuration spaceMaxima and minimaSoftware developerInformationLaptopFunction (mathematics)Point cloudQuicksortNumeral (linguistics)Process (computing)Installation artElectric generatorNumbering schemePresentation of a groupStandard deviationPlug-in (computing)Internet service providerFile formatConfiguration managementGeometryJSONXMLUMLComputer animationProgram flowchart
ImplementationPlug-in (computing)Software frameworkStochastic processRepository (publishing)Core dumpComputer configurationAddress spaceUniform resource locatorService (economics)Internet service providerAreaCodeEmailView (database)Revision controlDemo (music)Instance (computer science)Term (mathematics)Hydraulic jumpLanding pageSoftware frameworkNumberVapor barrierDifferent (Kate Ryan album)Right angleTerm (mathematics)Plug-in (computing)Core dumpComputer architectureProjective planeCodeStochastic processNeuroinformatikInternet service providerProcess (computing)Condition numberLatent heatServer (computing)Link (knot theory)Representation (politics)Computer animationJSONUMLXML
Uniform resource locatorDemo (music)Web pageRoutingOpen setInteractive televisionRepresentation (politics)RootSource codeJSONXML
Scale (map)RankingLimit (category theory)Representation (politics)RoutingRevision controlClient (computing)
Online helpTime domainCoordinate systemLatent heatComputer animation
Computer fontMatrix (mathematics)Time domainMetadataFile formatoutputStochastic processFunction (mathematics)Data typeMessage passingString (computer science)Asynchronous Transfer ModeLink (knot theory)InformationLetterpress printingEmailRow (database)Stochastic processImplementationResultantTesselationRepresentation (politics)Interactive televisionIntegrated development environmentInformation retrievalClient (computing)Instance (computer science)Front and back endsProcess (computing)Menu (computing)Computer animationXMLJSONUML
Theory of everythingLibrary catalogStatisticsImplementationLibrary catalogMoment (mathematics)Mechanism designComputer animation
TwitterProjective planeGeometrySoftware developerLattice (group)JSONXMLComputer animation
Block (periodic table)ImplementationClient (computing)Server (computing)Semantics (computer science)Uniform resource nameDefault (computer science)Finitary relationSoftware developerCore dumpInternetworkingInternet service providerPlug-in (computing)DisintegrationSoftware maintenanceConfiguration spaceHuman migrationPhysical systemEvent horizonComponent-based software engineeringPresentation of a groupPlug-in (computing)Internet service providerPresentation of a groupMechanism designHierarchyInterface (computing)NumberComponent-based software engineeringEvoluteCore dumpProjective planeLink (knot theory)Surface of revolutionSoftware developerImplementationPoint cloudOpen setFile formatWater vaporRootSoftware repositoryCuboidService (economics)Computer fileResultantHuman migrationDifferent (Kate Ryan album)Latent heatData exchangeOpen sourceConfiguration spaceWeb 2.0Letterpress printingNatural numberGeometryPoint (geometry)Front and back endsClient (computing)Wave packetComputer animationJSONXMLUML
Component-based software engineeringService (economics)MetadataService (economics)Computing platformIterationCentralizer and normalizerPoint (geometry)Geometry
Archaeological field surveyServer (computing)Limit (category theory)MathematicsDisintegrationBit rateZoom lensProcess (computing)Projective planeNumberServer (computing)Set (mathematics)Self-organizationImplementationXMLUMLJSONComputer animation
ImplementationData modelGraph (mathematics)InternetworkingWater vaporData typeNetwork topologyBit rateTrigonometric functionsSelf-organizationStandard deviationNumberSoftware bugComputer animation
ImplementationVisualization (computer graphics)Source codeCodeRevision controlBeta functionBranch (computer science)Presentation of a groupDemo (music)Web applicationPoint (geometry)Level (video gaming)Cartesian coordinate systemReal numberLink (knot theory)Stochastic processJSON
Plug-in (computing)GoogolQuery languageInternet service providerDatabase transactionTrigonometric functionsObject (grammar)FreewareOpen setPressureStandard deviationSheaf (mathematics)Web pageSource codeHecke operatorService (economics)Core dumpTotal S.A.Scale (map)InternetworkingLibrary catalogTime domainTorusLogic gateServer (computing)Group actionLine (geometry)Electronic mailing listLatent heatStandard deviationBitVapor barrierMappingLevel (video gaming)Internet service providerSelf-organizationSoftware developerService (economics)Home pageLink (knot theory)Software bugTwitterLine (geometry)ImplementationCore dumpProjective planeWave packetWeb pageCode refactoringTerm (mathematics)MereologyPlug-in (computing)Stochastic processNumberDatabase transactionQuery languageDifferent (Kate Ryan album)Computer animationSource codeXMLUML
Transcript: English(auto-generated)
Welcome to the presentation, and wow, look at all these people. It's great to see you all here, and Francesco and I, and the other PyJoo API developers who are in the crowd, you'll see them with the blue t-shirts, are excited to give you an update on this project. We'll walk through an overview of the project, core capabilities,
what we've been up to lately, and provide a showcase of selected projects and tell you where we're going. Overview, so the project was started in 2018 on Valentine's Day. I'm happy to say I'm still married, so fair enough.
And we're also an OGC project, so I'll provide some more information on that. So we've been there for a few years working on this stuff. The PyJoo API project itself is a geospatial data API framework that specializes on all the OGC API standards.
So that is our bread and butter in terms of the project. We support and are compliant to the OGC API standards, and we are also a reference implementation. We have a large international team, which is great across many time zones and numerous contributors from all over the world.
And like many open source projects, we leverage a lot of other open source projects which help us achieve our goal faster. So kudos to those upstream projects, as always. This is the impatient install. So this is one of my trademarks. If I can't install anything in five minutes, then I just forget about it.
So this is really important, and PyJoo API is no different in terms of getting you up and running for an API server. We have a core abstract API. You can actually use PyJoo API without using it over the web. We have a simple configuration management, and we have automated open API generation.
We have a plug-in architecture, which allows you to define and build your own plug-ins, depending on your requirements. It's very important for us to have minimal core dependencies. So you should be able to install this on your laptop without needing heavy-duty infrastructure or any big cloud things, for example,
and that continues to be a trademark of the project while allowing it to scale out to more elaborate deployment schemes. This is our sort of C4 architecture diagram of the project. So again, we have a core API in the middle, and we allow it to be used by any downstream web framework
in the Python sense. So whether your organization is using Flask or Starlet or FastAPI, the abstraction allows for any of those web frameworks to be used. And again, we have a plug-in framework which allows you to build out your own data providers, your own output formats, and your own processes.
There are some examples of what we do with our provider framework. So this has really been valuable for us in terms of having additional contributions from the community. So there's a number of different... I would say most of the work in PyJoo API these days
is building out these different providers. So it's really valuable to have that plug-in architecture to be able to have these things added relatively easily to the code base. As I mentioned, we do have a processing framework which is very popular for running maybe long-running jobs or intense computations.
You can implement your own. If you know Python, you can just implement it and tie it to the way PyJoo API does plug-ins, and you're off and running. Our deployment story is also a relatively low barrier, so we have a number of different ways to deploy. We have Docker support, obviously.
We're on Conda. We have Ubuntu GIS or Debian packages for those who are into that. So that's a core tenant of the project, is being able to have a number of different ways to deploy. I'll hand it over to Francesco.
So let's move into our core capabilities. There is a number of new OGC specifications that PyJoo API supports. This is the landing page of the server. It is represented by HTML, but on top right,
you see different links to jump into the JSON and JSONL representation. We obviously support the open API,
so you can reach basically what formerly known as the worker page on a root. And you can obviously, through this open API document, interact with the client and consume all the capabilities
that the PyJoo API supports. We support OGC API features, which is the stable version actually available from OGC. And obviously, you see in the HTML representation,
we support the different routes. So you can surf, navigate through the collection and for each specific collection through the items. And obviously, we offer pagination. So again, the client can consume and fetch
the collection and the items in a smart way. Also, these capabilities is not really stable yet, but we support the early specification of coverage.
And then as Tom already mentioned with PyCSW and again, in PyJoo API, we support OGC API records. There is an implementation, still
early implementation of OGC API tiles. We support pre-generated tiles that can be locally exposed or remotely. So you can, for instance, make available, for instance,
a menu bucket and consume an HTTP backend resource and publish your tiles through PyJoo API. We support, again, processes. As Tom already explained it, you
can obviously execute the process and get the result back in a RESTful way. And again, through a JSON representation, you can combine in a client the different interaction.
Also, we support OGC environment data retrieval, EDR, which is obviously more important for multidimensional data. And again, the stack implementation, we support static catalog at the moment, but there is the plan to add the stack API as well.
And finally, you can customize the PyJoo API HTML rendering with a template mechanism that PyJoo API offers. Lattice development.
We are officially a Nozgeo project after some months of incubation. So we have been graduated very good to all the team. Thank you very much. And this is quite important.
We usually participate with the team, the member team of the core developers in the different OGC API sprint that the OpenGeo Special Consortium is calling.
And yeah, so we are actually very focused on being updated with the specification that are moving on during the year.
We are even adding new specification, new implementation, like the roots. And thank you to the great work that the natural and schematics team have done. And so expect to use a lot of different OGC API
specification on top. And as Tom mentioned, obviously through the flexibility of the PyJoo API configuration, you basically can plug whatever you
want to be published to PyJoo API. So you are flexible to use PyJoo API for your own purpose. I can skip this. I think that's enough. That's still me. OK. We have new committers.
There is Joanna from the developer relation from the OGC. She's a longtime contributor to FOSS4G project. And we are very happy that she's on board on the PyJoo API project.
And then there is Ben Webb, who joined recently. He's working with the Lincoln Institute of Land Policy, Center of Geospatial Solutions. And he provides a very interesting new ESRI plugin to fetch an ESRI REST endpoint into PyJoo API
as a backend provider. So please have a look to the GitHub repo. There are a number of service providers that you can take a look on the link. We offer training, installation, setup, deployment.
We are cloud native, so you can ask for the support of cloud implementation of PyJoo API. And they can provide core development and so on. Hierarchical collection, we support this mechanism
of hierarchical collection. So you can combine very nested URI resources into PyJoo API to support different REST styling implementation and your custom interface for your clients.
There are a number of new features, new plugins like the ESRI that I mentioned at Socrada, Stack 8 OS. We support the migration on the HTML file to bootstrap,
publication of hidden results that you don't want to advertise on the open API document, and new format like GitHub support. And I'll pass the ball to Tom, please.
Thanks, Francesco. So we'll walk through some selected recent projects who have been using PyJoo API. The first one I'll talk to is WIS2 in a Box. So just putting a plug there for everybody
to attend our WIS2 in a Box presentation. So I'm giving that with Dave Barry from WMO later on today at 1230, if I'm not mistaken. And it uses PyJoo API for the API component. This project is a reference implementation, which represents an evolution or a revolution in the way
that international weather, climate, and water data exchange is going to happen at WMO. It's a free and open source project. And PyJoo API is baked inside of the API component. So we're very excited about this project. And we're going to present on it later today.
The US Geo platform has recently released an initial iteration based on PyJoo API. So this is providing a central point of access for federal geospatial metadata and services. So we're excited about their deployment. So kudos to them.
Emotional Cities also has an implementation, which concentrates on urban living correlated with mental health and well-being. So it's a pretty cool project to check out. The BGS, the British Geological Survey,
also has their own OGC API server powered by PyJoo API. And they make a number of their geological data sets available. So you can see here that they've implemented the custom templating that we discussed earlier. Great job there. GeoE3 is a geospatial enabled ecosystem for Europe.
And they also deploy using PyJoo API. A lot of organizations are starting to use the project and make their data available through the OGC API standard. So really exciting to see this. Some of these projects also contribute back also
a number of features and bug fixes and so on. GeoConnect is obviously one of them as well. It's the custom templating that they're using there. There's also something called River Runner, which is basically you click a point on the map and it sends a PyJoo API request. And a web application will do an animation
of how the river flows. You can point on anywhere in the world for that matter. So I encourage people to check out this presentation and the links in there and check out that application. It is absolutely fantastic to see it working live. Wish I can give a live demo, but happy to do that offline.
So really interesting use of PyJoo API for real processing. In terms of roadmap, we're not at a 1.0 yet. We do want to implement the OGC API maps and styles specifications. There is an OGC API sprint in late November, December,
in Brussels, if I'm not mistaken. So our goal, our target is to implement those specifications at that sprint. We do have a little bit of refactoring to do. So with any project that has a high amount of contributions and a lot of implementation,
you do have to step back once in a while and do some refactoring, and we do want to do that with the API. We also want to support transactions, so being able to create, update, and delete data accordingly in alignment with OGC API features part four, if I'm not mistaken. And there's also discussions on implementing
a Google BigQuery provider plug-in that Francesco's company is involved in. So that will be an upcoming feature that will be made available to the community. Again, here's our support page. So we have a number of different service providers, again, who can provide either core development, deployment,
customization, trainings, workshops, and so on. We gave a Diving into PyGEO API workshop on Monday for those of you who were able to attend that, so we thank you again for that. The workshop itself is online, so if you go to dive.pygeoapi.io, it's fully there for you to check out and get involved.
Or if you wanted to contact any of the commercial service providers, they're all made available there. If your company or organization wants to provide support for PyGEO API, you can get in touch and make a pull request and add your organization here as well.
So those are some links to the project. Again, that's our homepage. We have a Twitter channel, our documentation, and we're fully open. We have a Gitter channel for people to interact, so we welcome the community for suggestions and ideas,
bug fixes, contributions. There's been a lot of activity in this project in the last few years, and we're happy to see that the community is growing and the people behind it are dedicated to the project. We're fully in line with the OGC API standards, and I should also plug the OSGEO and OGC talk that Joanna, Codrina, and myself will do tomorrow,
which will touch upon some of the important aspects of that relationship, which PyGEO API is benefiting from to allow us to implement the standards in a very low-barrier way. So feel free to get involved.
We want to thank you for listening and thank you for your attendance and look forward to any questions or comments. Grazie.