Saravanan666/pypi-org huggingface dataset:
Package: geonode-elasticsearch-app
# geonode-elasticsearchThis application serves as an interface to elasticsearch in geonode via elasticsearch-dsl. Additionally provides some management commands for an easier upgrade from django-haystack.To use, add following to settings:``` python# elasticsearch-dsl settings# Elasticsearch-dsl Backend Configuration. To enable,# Set ES_SEARCH to True# Run "python manage.py clear_haystack" (if upgrading from haystack)# Run "python manage.py rebuild_index"ES_SEARCH = strtobool(os.getenv('ES_SEARCH', 'False'))if ES_SEARCH:INSTALLED_APPS = ('elasticsearch_app',) + INSTALLED_APPSES_URL = os.getenv('ES_URL', 'http://127.0.0.1:9200/')# Disable HaystackHAYSTACK_SEARCH = False# Avoid permissions prefilteringSKIP_PERMS_FILTER = False# Update facet counts from HaystackHAYSTACK_FACET_COUNTS = False```This app will provide a search api at /api/<resourcetype>/search/search.py contains definitions for the elasticsearch indices as well as functions to convert django models into form to go into elasticsearch.views.py contains all the logic for running the search and providing facets
Package: geonode-extract
Extract data from a GeoNode and dump it in a folderFeaturesDownloads data inshapefile formatDownloads metadata in xml formatDownloads styles in sld format (not yet implemented)InstallationGet the latest release usingpiporeasy_install:pip install geonode-extractUsagegeonode-extracthttp://demo.geonode.org-d <dest_dir>Known issuesDoes not work with layers with permissions enabledThanksThis package exists thanks to GFDRR and the World Bank’s OpenDRI initiative.
Package: geonode-oauth-toolkit
OAuth2 goodies for the Djangonauts!If you are facing one or more of the following:Your Django app exposes a web API you want to protect with OAuth2 authentication,You need to implement an OAuth2 authorization server to provide tokens management for your infrastructure,Django OAuth Toolkit can help you providing out of the box all the endpoints, data and logic needed to add OAuth2
capabilities to your Django projects. Django OAuth Toolkit makes extensive use of the excellentOAuthLib, so that everything isrfc-compliant.ContributingWe love contributions, so please feel free to fix bugs, improve things, provide documentation. Justfollow the
guidelinesand submit a PR.Reporting security issuesPlease report any security issues to the JazzBand security team at <security@jazzband.co>. Do not file an issue on the tracker.RequirementsPython 3.6+Django 2.2+oauthlib 3.1+InstallationInstall with pip:pip install django-oauth-toolkitAddoauth2_providerto yourINSTALLED_APPSINSTALLED_APPS=(...'oauth2_provider',)If you need an OAuth2 provider you’ll want to add the following to your urls.py.
Notice thatoauth2_providernamespace is mandatory.urlpatterns=[...path('o/',include('oauth2_provider.urls',namespace='oauth2_provider')),]ChangelogSeeCHANGELOG.md.DocumentationThefull documentationis onRead the Docs.Licensedjango-oauth-toolkit is released under the terms of theBSD license. Full details inLICENSEfile.
Package: geonode-ows-endpoints
GeoNode OWS endpoints---------------------This is simple application that will list used OWS (WMS, WFS and other) endpoints used by GeoNode instance. If integrated with directions from this file, endpoints should be available at `/api/ows_endpoints/` path.Requirements============*GeoNode<2.7 instance*. GeoNode 2.7 and newer have this application in core. This package is a backport of that application for older installations.Installation============1. install package with PIP:```pip install geonode-ows-endpoints```2. customize urlsIf you have customized urls, add following code to your urls file:```urlpatterns +=  [url('^', include('geonode_ows_endpoints.urls'))]```If you don't have customized urls, you can use urlpatterns provided by this application in `geonode_ows_endpoints.custom_urls`.  Then, you should also add following line to your settings file:```ROOT_URLCONF = 'geonode_ows_endpoints.custom_urls'```3. update your settingsInclude this in your settings.py file (or settings module pointed by `DJANGO_SETTINGS_MODULE`):```INSTALLED_APPS += ('geonode_ows_endpoints',)```Usage=====This application exposes URL which lists endpoints to OWS used by layers. It is used by GeoHealthCheck to automatically populate monitored resources from URL to home page of GeoNode instance.
Package: geonode_qgis_server
Django app to enable QGIS Server in GeoNode.DocumentationThe full documentation is athttps://geonode_qgis_server.readthedocs.org.QuickstartInstall geonode_qgis_server:pip install geonode_qgis_serverThen use it in a project:import geonode_qgis_serverFeaturesTODORunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements_test.txt
(myenv) $ python runtests.pyCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2016-06-21)First release on PyPI.
Package: geonode-user-accounts
PinaxPinax is an open-source platform built on the Django Web Framework. It is an ecosystem of reusable Django apps, themes, and starter project templates.
This collection can be found athttp://pinaxproject.com.This app was developed as part of the Pinax ecosystem but is just a Django app and can be used independently of other Pinax apps.django-user-accountsdjango-user-accountsprovides a Django project with a very extensible infrastructure for dealing
with user accounts.FeaturesFunctionality for:Log in (email or username authentication)Sign upEmail confirmationSignup tokens for private betasPassword resetPassword expirationAccount management (update account settings and change password)Account deletionExtensible class-based views and hooksetsCustomUsermodel supportRequirementsDjango 1.8, 1.9, 1.10 and 1.11Python 2.7, 3.3, 3.4, 3.5 and 3.6django-appconf (included ininstall_requires)pytz (included ininstall_requires)DocumentationSeehttp://django-user-accounts.readthedocs.org/for thedjango-user-accountsdocumentation.
We recently did a Pinax Hangout ondjango-user-accounts, you can read the recap blog post and find the video herehttp://blog.pinaxproject.com/2015/10/12/recap-september-pinax-hangout/.The Pinax documentation is available athttp://pinaxproject.com/pinax/. If you would like to help us improve our documentation or write more documentation, please join our Slack team and let us know!ContributeSee this blog posthttp://blog.pinaxproject.com/2016/02/26/recap-february-pinax-hangout/including a video, or our How to Contribute (http://pinaxproject.com/pinax/how_to_contribute/) section for an overview on how contributing to Pinax works. For concrete contribution ideas, please see our Ways to Contribute/What We Need Help With (http://pinaxproject.com/pinax/ways_to_contribute/) section.In case of any questions we recommend you join our Pinax Slack team (http://slack.pinaxproject.com) and ping us there instead of creating an issue on GitHub. Creating issues on GitHub is of course also valid but we are usually able to help you faster if you ping us in Slack.We also highly recommend reading our Open Source and Self-Care blog post (http://blog.pinaxproject.com/2016/01/19/open-source-and-self-care/).Code of ConductIn order to foster a kind, inclusive, and harassment-free community, the Pinax Project has a code of conduct, which can be found herehttp://pinaxproject.com/pinax/code_of_conduct/.
We ask you to treat everyone as a smart human programmer that shares an interest in Python, Django, and Pinax with you.Pinax Project Blog and TwitterFor updates and news regarding the Pinax Project, please follow us on Twitter at @pinaxproject and check out our bloghttp://blog.pinaxproject.com.
Package: geonode-user-messages
user-messagesis an application for allowing users of your Django site to
send messages to each other.Quick StartIncludeuser-messagesin your requirements file and add"user_messages"to your INSTALLED APPS setting.Once you have theuser-messagesinstalled, hook up the URLs:urlpatterns = patterns("",
    # some cool URLs

    (r"^messages/", include("user_messages.urls")),

    # some other cool URLs
)Now all you need to do is wire up some templates.
Package: geo-nuuuwan
GeoGeois a python library for drawing maps of Sri Lanka and its variousadministrative regions(Provinces, Districts, DSDs, GNDs etc).Installing Geopipinstallgeo-nuuuwanTutorial and ExamplesSeePlotting Maps of Sri Lanka with GeoPandas and MatPlotLibfor a Tutorial on using this library.SeeGitHubfor example code.Release History1.0.6 (NEXT RELEASE)1.0.5 (LATEST RELEASE)HACK: Removed caching from geodata1.0.4Fixed #BUG caused by repos using main, not master1.0.3Fixed bug with accessing ED/PD data1.0.2Added caching
Package: geopackage-python
geopackage-python : Python-based tools for creating OGC GeoPackages.GeoPackage Specification from the Open Geospatial
ConsortiumTable Of ContentsInstalling Dependencies
(Windows,Linux)How to use the tiling script,
gdal2tiles_parallel.pyHow to use the packaging script,
tiles2gpkg_parallel.pyRunning unit tests on
tiles2gpkg_parallel.pyDownload stable versionsRelease 5.0 - Archived on 2015-05-06- Python 3.4 support and better SQLite3 resource usageRelease 4.0 - Archived on 2015-04-30- Fix for incorrect tile matrix width and height valuesRelease 3.0 - Archived on 2015-02-11- Fix to include proper matrix sizes for height and width in gpkg_tile_matrix when those tiles do not existRelease 2.0 - Archived on 2015-01-13
Package: geopandas
GeoPandas is a project to add support for geographic data topandasobjects.The goal of GeoPandas is to make working with geospatial data in
python easier. It combines the capabilities ofpandasandshapely,
providing geospatial operations in pandas and a high-level interface
to multiple geometries to shapely. GeoPandas enables you to easily do
operations in python that would otherwise require a spatial database
such as PostGIS.
Package: geopandas-postgis
GeoPandas-PostgisUtilities oriented to using PostGIS features.Installpipinstallgeopandas-postgisRequirementsGeoPandasGeoAlchemy2SQLAlchemypsycopg2UsageCurrently, thepostgisaccessor only features ato_postgismethod.importgeopandasasgpdfromsqlalchemyimportcreate_enginefromgeopandas_postgisimportPostGISengine=create_engine("postgresql+psycopg2://postgres:postgres/localhost:test")my_gdf=geopandas.read_file("my_shp.shp")my_gdf.postgis.to_postgis(con=engine,table_name='test',geometry='Polygon')Theto_postgismethod will accept any keyword argument in the to_sql method inpandasTestingPostgres needs to be running on your local machine with a postgres user (that has write access.)  This will be moved to Docker over time.LicenseMIT LicenseCopyright (c) 2018 Aaron BurgessPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: geoparquet
GeoParquetGeoParquet for Python is a GeoPandas API designed to facilitate fast
input/output of GIS data in the open source Parquet file format.The project is currently a proof of concept.Why is this project needed?The GIS community currently lacks a fast, efficient, open-source file format for
persisting and sharing data with. The purpose of the GeoParquet project is to
develop such a file format.How does it work?The GeoParquet file format is simple adaptation of the existing Parquet file
format: geometries are stored as well-known binary (WKB), and the coordinate
reference system is stored as a WKT string (specifically WKT2_2018) in the
file's metadata.Basic usageimportgeopandasasgpdimportgeoparquetasgpq# read in file from shapefile or other format using geopandasgdf=gpd.read_file('example file.shp')# call .to_geoparquet() method on geopandas GeoDataFrame to write to filegdf.to_geoparquet('example file.geoparquet')# read from file by calling gpq.read_geoparquet() functiongdf=gpq.read_geoparquet('example file.geoparquet')
Package: geoparquet-pydantic
# GeoParquet-PydanticMotivation:This project started at the 2024 San Fransisco GeoParquet Community hackathon, and arose out of a simple observation:
why must Python users install themassiveGDAL dependency (typically via GeoPandas) to do simple GeoJSON<>GeoParquet conversions.Is this library the right choice for you?:* Do you need to use a wide variety of Geospatial functions? If so, you will likely have to add GDAL/GeoPandas as a dependency anyways,
making this ibrary’s conversion functionsprobablyredundant.
* Is your workflow command line centric? If so you may want to consider Planet Lab’s simular CLI tool [gpq](https://github.com/planetlabs/gpq),
which is written in Go and substantially faster.
* Otherwise, if you are using Python and want to avoid unnecessary bulky dependencies, this library will be a great choice!Note:All user-exposed functions and schema classes are available at the top level (i.e.,geoparquet_pydantic.validate_geoparquet_table(…)) of this library.# Documentation is on GitHub [here](https://github.com/xaviernogueira/geoparquet-pydantic/blob/main/README.md)# Getting StartedInstall from [PyPi](https://pypi.org/project/geoparquet-pydantic):`bash pip installgeoparquet-pydantic`Or from source:`bash $ git clonehttps://github.com/xaviernogueira/geoparquet-pydantic.git$ cdgeoparquet-pydantic$ pip install . `Then import with an underscore:`python import geoparquet_pydantic `Or just import the functions/classes you need from the top-level:`python from geoparquet_pydantic import GeometryColumnMetadata from geoparquet_pydantic import GeoParquetMetadata from geoparquet_pydantic import validate_geoparquet_table from geoparquet_pydantic import validate_geoparquet_file from geoparquet_pydantic import geojson_to_geoparquet from geoparquet_pydantic import geoparquet_to_geojson `# Roadmap[ ] Make CLI file<>file functions w/click.[ ] Add parrallelized Parquet read forgeoparquet_pydantic.geoparquet_to_geojson().# ContributeWe encourage contributions, feature requests, and bug reports!Here is our recomended workflow:Usedev-requirements.txtto install our development dependencies.Make your edits usingpyrightas a linter.Usepre-commit run –all-filebefore commiting your work.If you add a new feature, we request that you add test coverage for it.Happy coding!
Package: geopathfinder
geopathfinderA package for creating, querying, and searching in data structures holding geo data sets.DescriptionThis packages aims to provide a rich toolbox for efficient, quick, and precise handling of filenames and folder structures for geo-data, most conviniently when combined with grid objects as e.g. thehttps://github.com/TUW-GEO/Equi7Grid.With pre-defined sets comprising string-definitions, folder path logics, and filename en-/decoders, a variety of file/folder naming conventions can be implemented.The base classes SmartPath() and SmartTree() comprise also functions for file search and folder(-tree) volume determination.Adding a new filenaming conventionIn general, please follow the code and test guidelines of existing naming conventions.
The following description aims to show how to implement a new naming convention:Create a new .py file in the folder “geopathfinder/naming_conventions/”. The filename should be an abbreviation of the new naming convention separated from “naming” with an underscore, e.g., “sgrt_naming.py” ot “eodr_naming.py”.Inside this file, write a new class, which inherits fromSmartFilename. In this class you can define how the filename structure should look like. For each field you can define the length of the field (‘len’, integer), the start index of a field (‘start’, integer), if a delimiter should be in between the current and the previous part of the filename (‘delim’, boolean) and finally, if desired, a decoding and encoding function (‘decoder’, ‘encoder’). The latter parameters should point via a lambda function to a decoding or encoding method defined in the same class.Finally, the parent classSmartFilenamecan be initiated with the given fields, fields definitions, a padding, a delimiter and a boolean value if en-/decoding should be applied or not.If you want to read a filename with your created class, you can overwrite the class methodfrom_filenameand use your field definitions for the parent class method callfrom_filename.Sometimes one needs information from a part of a filename, which can be directly derived/decoded from one or multiple filename entries. An example would be a mean date derived from the start and end date specified in the filename.
To allow this, one can define methods tagged withpropertyin the current class.SmartFilenamethen handles the properties of the inherited class equally to a common filename entry given in the field definition.Add tests to “tests” and name the test file “test_[]_naming.py”, where “[]” should be replaced by the abbreviation of the new naming convention.NoteThis project has been set up using PyScaffold 3.1. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: geopatra
Create Interactive maps 🗺️ with your geodataframeGeopatra extends geopandas for interactive mapping and attempts to wrap the goodness of amazing mapping libraries like Folium, Plotly, Kepler.gl, hvplot etc for rapidly creating interactive maps with GeodataframesYou can already create interactive maps easily with geopandas and Folium/ Plotly/ Kepler.gl. Geopatra is merely meant to make this easier and is more geared towards ease and currently does not support complex maps or intricate style controlInstallationEverything is always a pip awaypip install geopatraBasic UsageTo quickly plot a geodataframe with folium, you gotta understand workflows in geopandas and folium.importfoliumimportgeopandasworld=geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))m=folium.Map(location=[4,10],zoom_start=3)folium.GeoJson(world.__geo_interface__).add_to(m)With Geopatra all the parameters you set with folium become optional so you don't have to care about foliumimportgeopatram=world.folium.plot()Now you have a folium map object, which you can now use for more complex mapflowsCheck outdocsfor more examplesDevelopmentClone the repogit clone git@github.com:Sangarshanan/geopatra.gitRunpre-commit installto install pre-commit into your git hooks. pre-commit will now run on every commitInstall the package with the amazingpoetrypoetry installMake the bla-bla-bla changes to code and run the tests and when full moon is nigh, build & publishpoetry build
poetry publishTo update versionspoetry add geopandas@^0.8.0
Package: geopayment
AboutGeoPayment - Python SDK for Georgian Payment ProvidersPrerequisitesPython >= 3.7.xcryptography >= 3.3.2pyOpenSSL >= 21.0.0requests >= 2.26.0Quick StartInstallgeopaymentpackage$pipinstallgeopaymentIntegrate your appsModulesFor TBCPayFor TBC InstallmentFor iPay (BOG)For BOG InstallmentFor Credo InstallmentLicenseCopyright © 2017 Lasha Gogua.MIT licensed.
Package: geopdf
GeoPDF======[![Build Status](https://travis-ci.org/garnertb/geopdf.svg?branch=master)](https://travis-ci.org/garnertb/geopdf)GeoPDF is a simple wrapper around [ReportLab](http://www.reportlab.com/) that allows developers to create basic GeoPDFs byfollowing the [GeoPDF Encoding Best Practices](http://portal.opengeospatial.org/files/?artifact_id=33332)published by the Open Geospatial Consortium.  In its current state, this project only exposes the bare minimum needed fordevelopers to create a GeoPDF in reportlab.Installation============Install this project from PyPI by running the command below:```$ pip install geopdf```or alternatively from source (github mater):```$ pip install git+https://github.com/garnertb/geopdf.git#egg=geopdf```Creating a GeoPDF=================If you have worked with reportlab before, GeoPDF should feel familiar.  GeoPDF subclasses the reportlab Canvas so you get allof the API methods you are used to along with some additional geospatial methods!Example-------In this example, we create a 200 x 200 empty rectangle with the bounds of the earth in WGS 1984 (-180, -90, 180, 90).  The maininterface you need to be familiar with is the `canvas.addGeo` method which adds the GeoPDF dictionary (called `LGIDict`)to the PDF.  GeoPDF uses a geographic projection by default so in a minimal example you only have set theregistration points (which tie PDF pixel locations to map locations) and you're done.  The `addGeo` method updates the LGIDict with anykeyword arguments that you pass it so refer to the [GeoPDF Encoding Best Practices](http://portal.opengeospatial.org/files/?artifact_id=33332)document to learn about all of the things that the GeoPDF supports.```from geopdf import GeoCanvasfrom reportlab.pdfbase.pdfdoc import PDFString, PDFArraycanvas = GeoCanvas('example1.pdf')canvas.rect(200, 400, 200, 200, stroke=1)# A series of registration point pairs (pixel x, pixel y, x, y)registration = PDFArray([PDFArray(map(PDFString, ['200', '400', '-180', '-90'])),PDFArray(map(PDFString, ['200', '600', '-180', '90'])),PDFArray(map(PDFString, ['400', '600', '180', '90'])),PDFArray(map(PDFString, ['400', '400', '180', '-90']))])canvas.addGeo(Registration=registration)canvas.save()```Issues======Please report any bugs or requests that you have using the GitHub issue tracker!Notes=====- http://portal.opengeospatial.org/files/?artifact_id=33332Contributing============- Fork the repository on GitHub- Create a named feature branch (like `add_component_x`)- Write your change- Write tests for your change (if applicable)- Run the tests, ensuring they all pass- Submit a Pull Request using GitHub
Package: geo-places
geo locationsA simple package for managing czech municipalities. It enables to scrape source data (czech municipalities together with their GPS coordinates), store them into ES index and then make queries.InstallationUsing pippip3 install geo-placesDirectly from githubpip3 install git+https://github.com/bauerji/geo_locations.gitUsageLocation index preparationimportasynciofrompathlibimportPathfromgeo_places.datasetimportgener_datasetfromgeo_places.elasticsearch.handlerimportElasticClienturl="https://wwwinfo.mfcr.cz/ares/obce/ares_obce.html.cz"# this is a default path where the data file lands after package installationpath=Path("/usr/local/data/municipality_population.csv")asyncdefpopulate():es=ElasticClient("localhost")awaites.index_location_objects(gener_dataset(path))defmain():asyncio.run(populate())if__name__=='__main__':main()Location suggestfromgeo_places.elasticsearch.handlerimportElasticClientif__name__=='__main__':es=ElasticClient("localhost")suggestions=es.suggest_location("hor")forsuggestioninsuggestions:print(suggestion.name,suggestion.population)Location searchfromgeo_places.elasticsearch.handlerimportElasticClientif__name__=='__main__':es=ElasticClient("localhost")results=es.search_location("prha 10",fuzzy=True)forresultinresults:print(result)TODOs:tests
Package: geoplanar
geoplanarPlanar enforcement for polygon geoseriesgeoplanarsupports the detection and correction of violations ofplanar enforcementfor polygon geoseries including:missing holesnonplanar coincident edgesnonplanar touchesoverlapssliversStatusgeoplanaris currently in alpha status and is open to contributions that help shape the scope of the package. It is being developed in support ofresearchand is likely to be undergoing changes as the project evolves.Fundinggeoplanaris partially supported byNSF Award #1759746, Comparative Regional Inequality Dynamics: Multiscalar and Multinational Perspectives