Saravanan666/pypi-org huggingface dataset:
Package: geode-ml
How to installgeode-mlThegeode-mlpackage depends onGDALandTensorflowfor most of its functionality. It is easiest to installGDALusing thecondapackage manager:conda create -n "geode_env" python>=3.7
conda activate geode_env
conda install gdalHowever, installingTensorflowwith Conda is trickier; we recommend following official documentation for installing
the cuDNN and CUDA Toolkit libraries with thecondapackage manager (if you have a compatible GPU), and then doingpip install tensorflow-gpuAfter activating an environment which has bothGDALandTensorflow, usepipto installgeode-ml:pip install geode-mlThe geode.datasets moduleThe datasets module currently contains the class:SemanticSegmentationcreates and processes pairs of imagery and label rasters for scenesThe geode.losses moduleThe losses module contains custom loss functions for model training; these may be removed in the future when implemented
in Tensorflow.The geode.models moduleThe models module contains the classes:Segmentationsubclass of the tensorflow.keras.Model class to be used for image segmentationUnetsubclass of the Segmentation class which instantiates a Unet architecture.The geode.utilities moduleThe utilities module currently contains functions to process, single examples of geospatial data. The datasets module
imports these functions to apply to batches of data; however, this module exists so that methods can be used by
themselves, without instantiating a class object from another module.
Package: geodemo
geodemoA Python package for interactive mappingFree software: MIT licenseDocumentation:https://giswqs.github.io/geodemoInstallationpippip install -U geodemoHow to publish a Python package on conda-forgeHere is a quick start guide for publishing a Python package on conda-forge. More information can be found in thisvideo tutorial.Install conda-build using:conda install conda-buildCreate the conda recipe using:conda skeleton pypi package-nameMake changes to the recipe (meta.yaml) by following thisexample. A few key items to change: addnoarch: pythonunder thebuildsection; remove all packages exceptpipandpythonfrom thehostsection; specify a python version (e.g., >=3.6) for both thehostandrunsections; addLICENSE,doc_url, anddev_urlto theaboutsection; add your GitHub username to therecipe-maintainerssection.Forkhttps://github.com/conda-forge/staged-recipesAdd your package recipe tostaged-recipes/recipes/package-name/meta.yamlCommit changes and push to GitHubSubmit a pull request (e.g.,https://github.com/conda-forge/staged-recipes/pull/14285)Wait for the recipe to pass all checks@conda-forge/help-pythonto let them know that your recipe is ready for review.Once your recipe is accepted, your package feedstock should become available within a few hours (e.g.,geodemo-feedstock).The link to your package on conda-forage should behttps://anaconda.org/conda-forge/package-name, such ashttps://anaconda.org/conda-forge/geodemoCreditsThis package was created withCookiecutterand thegiswqs/pypackageproject template.
Package: geodemo-fm
geodemo_fmWelcome to geodemo_fmA Python package for interactive mapping with Google Earth Engine, ipyleaflet, and ipywidgets.This package is used for georeferencingFree software: MIT licenseDocumentation:https://faraigit.github.io/geodemo_fmFeaturesTo do
To do 2CreditsThis package was created withCookiecutterand thegiswqs/pypackageproject template.
Package: geodense
geodensePython library and CLI tool tocheck densityanddensifygeometries
using the geodesic (ellipsoidal great-circle) calculation for accurate CRS
transformations.Implementation based onEenduidige transformatie van grenzen tussen ETRS89 en
RDRequires Python v3.11 or higher.Depends on:pyproj ~= 3.6.0->requires PROJ
9+shapely ~= 2.0.2->requires GEOS >=
3.5Usage CLIUse eithergeodenseor the shortgdenalias:$ geodense --help

Usage: geodense [-h] [-v] {densify,check-density} ...

Check density of, and densify geometries using the geodesic (ellipsoidal great-circle) calculation for accurate CRS transformations

Commands:
  {densify,check-density}

Options:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit

Created by https://www.nsgi.nl/Usage DocsSeeDOCS.mdfor usage docs; for now only containing flow-charts of thedensifyandcheck-densifysubcommands.ContributingIssues (bugs/feature requests) can be reported in theissue tracker of this
repository. Pull
requests are more than welcome, but we encourage to start a discussion on the
issue tracker first.DevelopmentInstall/uninstall geodense for development, including dev dependencies (run from
root of repository):pipinstall-e".[dev]"pipuninstallgeodenseTestsRun tests:python3-mpytesttests/Check test coverage:python3-mcoveragerun-p--source=src/geodense-mpytest-vtests&&python3-mcoveragereport--data-file$(ls-t.coverage.*|head-1)Create releaseCreating a release requires thebuildandtwinepackages, which are part of
this package'sdevdependencies. To create a release follow these steps:To release a new version create a new git tag and push the new tag withgittag-ax.x.x-m"tagging x.x.x release"gitpush--tagsCreate a new build with:rm-rfdist/*# clean dist folder before buildpython-mbuildCheck wheel contains expected files:unzipdist/geodense-0.0.1a3-py3-none-any.whl-dgeodense-whl
treegeodense-whl
rm-rfgeodense-whlCheck whether package description will render properly on PyPI:twinecheckdist/*Upload release to pypi:twineupload-rtestpypidist/*Note:requires~/.pypircfile with API token (when 2FA is enabled on PyPi).
Package: geodesic-chenhan
geodesic-chenhanThis is an updated fork of the originalchenhan_cythonrepo. It usespyproject.tomlto pre-installCythonandautowrapbefore the compilation step, so that you don't need to install it beforehand. It also has some slight changes to the C++ code to make it work for some
projects I'm working on.Future work will focus on creating an interface for this module to work with theTrimeshlibrary.
Package: geodesicDome
GeodesicDome(freq=0)Class wrapper to create and interact with a Geodesic DomeCreates a given geodesic dome with a given frequency.Args: freq (int, optional): The frequency of the geodesic dome.
Defaults to 0.Methodsfind_neighbours(self, index: numpy.int64, depth=1) ‑> numpy.ndarrayFinds the neighbours of a given vertex on the geodesic dome to a
certain depth (defaults to 1 if not provided)Args: index (np.int64): The index of the vertex to search from
depth (int, optional): The depth of neighbours to return. Defaults
to 1.Returns: np.ndarray: An array containing the indices of all the
vertex’s neighboursget_triangles(self) ‑> numpy.ndarrayGetter function for trianglesReturns: np.ndarray: the triangles of the geodesic domeget_vertices(self) ‑> numpy.ndarrayGetter function for verticesReturns: np.ndarray: the vertices of the geodesic dometessellate(self, freq=1) ‑> NoneTessellates the geodesic dome a given number of times (tessellates
once if no arguments provided)Args: freq (int, optional): The number of times to tessellate.
Defaults to 1.
Package: geodesk
GeoDesk is a fast and storage-efficient geospatial database for OpenStreetMap data.
Also availablefor Java.Why GeoDesk?Small storage footprint— GeoDesk's GOL files are only 20% to 50% larger than the original OSM data in PBF format — that's less than a tenth of the storage consumed by a traditional SQL-based database.Fast queries— typically 50 times faster than SQL.Fast to get started— Converting.osm.pbfdata to a GOL is 20 times faster than an import into an SQL database. Alternatively, download pre-made data tiles for just the regions you need and automatically assemble them into a GOL.Intuitive API— No need for object-relational mapping; GeoDesk queries return Python objects. Quickly discover tags, way-nodes and relation members. Get a feature's geometry, measure its length/area.Proper handling of relations— (Traditional geospatial databases deal with geometric shapes and require workarounds to support this unique and powerful aspect of OSM data.)Seamless integration with Shapelyfor advanced geometric operations, such as buffer, union, simplify, convex and concave hulls, Voronoi diagrams, and much more.Modest hardware requirements— If it can run 64-bit Python, it'll run GeoDesk.Get StartedRequirementsPython 3.7 or aboveJava 16 or above (for the GOL Tool)Downloadpip install geodeskCreate a GOLCreate a Geographic Object Library based on any.osm.pbffile, using theGOL Tool(Requires Java 16+).For example:gol build switzerland switzerland-latest.osm.pbfExample ApplicationFind all the pubs in Zurich (Switzerland) and print their names:fromgeodeskimport*# Open switzerland.golfeatures=Features("switzerland")# Get the feature that represents the area of the city of Zurichzurich=features("a[boundary=adminstrative][admin_level=8][name:en=Zurich]").one# Define a set that contains nodes and areas that are pubspubs=features("na[amenity=pub]")# Iterate through the pubs that are contained in the area of Zurich# and print their namesforpubinpubs.within(zurich):print(pub.name)More ExamplesFind all movie theaters within 500 meters from a given point:movieTheaters=features("na[amenity=cinema]").around(meters=500,lat=47.37,lon=8.54)Remember, OSM uses British English for its terminology.Discover the bus routes that traverse a given street:forrouteinstreet.parents("[route=bus]")):print(f"-{route.ref}from{route.from}to{route.to}")Count the number of entrances of a building:number_of_entrances=building.nodes("[entrance]").countDocumentationGeoDesk Developer's GuideRelated Repositoriesgeodesk— GeoDesk for Javagol-tool— command-line utility for building, maintaining and querying GOL files
Package: geode-solutions-wslink
Wslink allows easy, bi-directional communication between a python server and a
javascript client over awebsocket. The client can make RPC calls to the
server, and the server can publish messages to topics that the client can
subscribe to. The server can include binary attachments in these messages,
which are communicated as a binary websocket message, avoiding the overhead of
encoding and decoding.RPC and publish/subscribeThe initial users of wslink driving its development areVTKandParaView.
ParaViewWeb and vtkWeb require:RPC - a remote procedure call that can be fired by the client and return
sometime later with a response from the server, possibly an error.Publish/subscribe - client can subscribe to a topic provided by the server,
possibly with a filter on the parts of interest. When the topic has updated
results, the server publishes them to the client, without further action on
the client’s part.Get the whole storyThis package is just the server side of wslink. See thegithub repofor
the full story - and to contribute or report issues!LicenseFree to use in open-source and commercial projects, under the BSD-3-Clause license.
Package: geodestic
# geodesticThis module provides a single function: between()It takes four floats corresponding to two latitude/longitude sets given in decimal degrees and returns a value that corresponds to the length of the geodesic distance between those two coordinates.  The bearing calculation bits of the original source are not a part of this module.The tests run against geographiclib. It is thought to be the most precise and speedy open source library for GIS calulations. There is an accompanying python implementation (not bindings) written by the author of the C++ library. (_pip install geographiclib_) It is quite a bit slower than the C++ implementation and my cffi-fu is not quite up to wrapping it in way that I would feel confident using it.Thanks to the Android team the for the clear expression of the inversion forumla. (http://tw.gs/2Xyci3)
Package: geodetector
GeoDetectorThis is a simple GeoDetector which can be used to the determinant
power of a covariate X of Y.Now only interaction_detect, and q_values is available.Installpipinstallgeodetectorthen the geodetector will be installedhere is a basic example
```python
from geodetector import geodetector

df = load_disease()
gd = GeoDetector(df,["type", "region", "level"], "incidence")

# directly plot the result
gd.plot() # show the q_values bar of each covariate
gd.plot_interaction() # show the interaction bar of each covariate

# interaction detect and save the result
result = gd.interaction_detect()
result.to_excel("q.xlsx")
Package: geodezyx
The purpose of this GeodeZYX toolbox is to provide all the functions which
can be useful for Geodesy and Geophysics.It includes low level functions, file management functions,
time and space-coordinates conversion functions,
data (especially GNSS observations and orbits) retrieve functions,
plots and visual selection functions …It is designed for Python 3 on a LINUX Ubuntu-like system.
Also tested with AnacondaDocumentation:https://geodezyx.github.io/geodezyx-toolboxGitHub repository:https://github.com/IPGP/geodezyx-toolboxPyPi project:https://pypi.org/project/geodezyx
Package: geodist
GeodistFinds the distance between a POI (point of interest) and a geometric shape on Earth's surfaceObjectiveFind the distance between a point of interest and a geometric shape – polygon, circle, line string and a Point on earth’s surface using latitude and longitude associated with the geographic coordinate systemInstallpip install geodistHow Does It Work?First, we convert an array of points (lng, lat) to a planar geometric object.Then, we project the geometric object from the World Geodetic System (aka: WGS84) to the World Azimuthal Equidistant Projection (aka: ESRI:54032) with our POI as the center point of the projection.The azimuthal equidistant projection is a map projection where all points on the map are at proportionally correct distances from the center.ExamplesPolygonThe distance between a polygon and a POI>>> from geodist import GeoDist
>>> coords = [(4.3466824, 50.8584046), (4.3371552, 50.8490306), (4.3429917, 50.8336379), (4.3488282, 50.8330958),
...           (4.3658226, 50.8409013), (4.3695992, 50.8473506), (4.3679684, 50.8526612), (4.3466824, 50.8584046)]
... 
>>> lng, lat = 4.3821081, 50.8133681
>>> GeoDist(coords).distance(lng, lat)
3153.3015428957347CircleThe distance between circles and a POI>>> from geodist import GeoDist
>>> coords = [(-77.120923, 39.056418)]
>>> lng, lat = -77.145146, 39.047193
>>> GeoDist(coords, radius=1000).distance(lng, lat)
1334.582257003439
>>> GeoDist(coords, radius=2000).distance(lng, lat)
335.7868006642301
>>> GeoDist(coords, radius=3000).distance(lng, lat)
663.0086557682768Another feature of GeoDist can tell if the POI is inside or outside the shape:>>> a = GeoDist(coords, radius=1000)
>>> distance = a.distance(lng, lat)
>>> a.within
False

>>> b = GeoDist(coords, radius=3000)
>>> distance = b.distance(lng, lat)
>>> b.within
TrueLinestringThe distance between a Linestring and a POI>>> from geodist import GeoDist
>>> coords = [(-121.77919, 36.24285), (-121.77939, 36.24317), (-121.77955, 36.24336), (-121.77967, 36.24347),
          (-121.77977, 36.24358), (-121.78, 36.24378), (-121.78033, 36.24409), (-121.78052, 36.24433),
..............]
>>> lng, lat = -121.88728, 37.33901
>>> GeoDist(coords).distance(lng, lat)
39603.30198998547
Package: geodjango-tigerleaflet
=============================geodjango-tigerleaflet=============================Make use of Geodjango, Leaflet.js, US Census TIGER data to allow navigation throughdata related to US States and CountiesQuickstart----------Install geodjango-tigerleaflet::pip install geodjango-tigerleafletAdd it to your `INSTALLED_APPS`:.. code-block:: pythonINSTALLED_APPS = (...'tigerleaflet',...)Add geodjango-tigerleaflet's URL patterns:.. code-block:: pythonfrom tigerleaflet import urls as tigerleaflet_urlsurlpatterns = [...url(r'^', include(tigerleaflet_urls)),...]Features--------* GeoJson urls for easy map creation* example Leaflet pages for displaying and navigating through state/county data* template tags for users to use in their own templatesTodo--------* Push models back into geodjango-tigerline once it's upgraded to use Django 1.10* Better documentation on pypi* Better examples, even with some adding data on top of states/counties showcasing use of leaflet library* Offer direct download and import of census data (like django-brasil-municipios)Credits-------Tools/packages used in rendering this package:*  Cookiecutter_*  `cookiecutter-djangopackage`_*  `geodjango-tigerline`_.. _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage.. _`geodjango-tigerline`_: https://github.com/adamfast/geodjango-tigerlineHistory-------0.2.0 (2017-01-29)++++++++++++++++++Add template tags for users to use in their own templates0.1.0 (2016-12-21)++++++++++++++++++* First release on PyPI.
Package: geodjango-tigerline
This app is intended to make it easier to add TIGER/Line data to a GeoDjango project and save people from writing this same code over and over (collectively).It is not (yet) exhaustive, it’s just what I had and have needed in the past.
If you have models / load scripts for other data in the set, please fork/add and send me a pull request if you add other shapefiles. If you come up with useful manager methods, I’d love to see those too.NOTE: If you need cities, the best source for that is the US National Atlas. I have an app for those athttps://github.com/adamfast/usgsdata-citiesx020It’s been tested and used with Django 1.10 and PostGIS + PostgreSQL.InstallDownload the 2016 Tigerline files for all zipcodes, all states, and all countiesftp://ftp2.census.gov/geo/tiger/TIGER2016/States (and Territories) -ftp://ftp2.census.gov/geo/tiger/TIGER2016/STATE/tl_2016_us_state.zipCounties (for all States / Territories -ftp://ftp2.census.gov/geo/tiger/TIGER2016/COUNTY/tl_2016_us_county.zipZipcode Tabulation Areas (for all States / Territories, these are NOT actual zip codes which describe specific mail routes) -ftp://ftp2.census.gov/geo/tiger/TIGER2016/ZCTA5/tl_2016_us_zcta510.zipUnzip the filesConfigure django.contrib.gis as described in the django docs.Add “django.contrib.gis” and “tigerline” to INSTALLED_APPSrunpython manage.py migratewhich will run the migrations and make sure database tables are created.If you want to import all three:
runpython manage.py load_tigerline –path=~/Path/to/shapefilesOr there are individual management commands if you only need one set:
runpython manage.py load_counties –path=~/Path/to/shapefilesrunpython manage.py load_states –path=~/Path/to/shapefilesrunpython manage.py load_zipcodes –path=~/Path/to/shapefiles
Package: geodjango-timezones
This app provides models to store Timezone data from a couple sources:Timezone Boundary Builder (https://github.com/evansiroky/timezone-boundary-builder) which uses OpenStreetMap data to generate shapefiles as well. You can download timezones.shapefile.zipthe Creative Commons Zero shapefile (the _mp version which uses multipolygon fields) published athttp://efele.net/maps/tz/world/, as well as a script to load the data into your database. (last version tested was data from May 28, 2016) This data source is no longer maintained by its author.It’s useful for applications where the user enters times related to a location (i.e. specifying a pickup time for a rental car, or business hours)It is useful for finding tzids you can feed to datetime and Django from a geometry if you know WHERE that time is.fixtures/ contains timezones.json which includes an archived copy of the data for the United States for testing purposes. As this data may change, make sure you use the shapefile and not this data for your application.Tested with Django 1.11 on Python 2.7INSTALLATION:To install, add ‘timezones’ to your installed apps and runmanage.py migrateLoading is accomplished by usingmanage.py load_timezones –path=<path_to_shapefile_directory>`, the app will automatically add the appropriate “tz_world_mp.shp” to the end of the path.IF you are using the Creative Commons Zero shapefile from efele.net that is no longer being updated, you will need to pass –tz_world to
Package: geoDL
Please note that geoDL is in beta version, therefore expect bugsgeoDL is a python program to download FASTQ files fromGEO-NCBI. The program inputs a #GEO access number and perform a search on theEMBL-EBI/ENAwebsite to gather metadata and download FASTQ files. The metadata are used to rename the samples with the experiment sample names (rather than the SRR numbers).DependenciesgeoDL should work with bothPython3andPython2but test have to be run stillBeautifulsoup4,coloramaandsixpython package are requiredwgetis used internally and thus is a dependency of geoDLInstallOn linux and MacOSx$pipinstall--usergeoDLNote it is possible that the flag–preis needed for installing the beta version.Usageusage:geoDL.py[-h][--dry][--samples[SAMPLES[SAMPLES...]]][--colnameCOLNAME]{geo,meta,ena}GSE|metadata|ENA{geo,meta,ena}SpecifywhichtypeofinputGSE|metadata|ENAgeo:GSEaccessionnumber,eg:GSE13373MaptheGSEaccessiontotheENAstudyaccessionandfetchthemetadatameta:UsemetadatafileinsteadoffetchingitonENAwebsite(bypassGEO)Metadatashouldincludeatminimathefollowingcolumns:['Fastq files
                            (ftp)','Submitter'ssamplename']

                      ena:  ENA study accession number, eg: PRJEB13373
                            Fetch the metadata directely on the ENA website

  optional arguments:
    -h, --help            show this help message and exit
    --dry                 Don'tactuallydownloadanything,justprintthewgetcmds--samples[SAMPLES[SAMPLES...]]SpaceseparatedlistofGSMsamplestodownload.ForENAmode,subsetthemetadata--colnameCOLNAMENameofthecolumntouseinthemetadatafiletonamethesamplesExampleDownload metadata and all the samples of the serie GSE13373 and rename them to their sample names:$geoDLgeoGSE13373Download only some samples:$geoDLGSE13373-sGSM00001GSM00003Download use a pre downloaded metadata and use column run_alias as name for the samples:$geoDLmetamy_metadata.txt--columnrun_aliasUse a ENA code instead of a GSE code:$geoDLenaPRJEB13373Beta testTest python2 supportTest handling of wgetChangelogchangelog
Package: geodock
GeoDockOfficial repository forGeoDock: Flexible Protein-Protein Docking with a Multi-Track Iterative Transformer.Try protein docking inGoogle ColabBug reportsIf you run into any problems while using GeoDock, please create aGithub issuewith a description of the problem and the steps to reproduce it.Citing this work@article{chu_flexible_2023,title={Flexible {Protein}-{Protein} {Docking} with a {Multi}-{Track} {Iterative} {Transformer}},author={Chu, Lee-Shin and Ruffolo, Jeffrey A and Harmalkar, Ameya and Gray, Jeffrey J}url={https://www.biorxiv.org/content/early/2023/07/01/2023.06.29.547134},doi = {10.1101/2023.06.29.547134},
Package: geodome
Geodesic DomeGeodome is a python library that enables users to manipulate a 3D geodesic dome.
The library provides the capability for users to store data in vertices and
manipulate the overall structure of the dome. There are options to tessellate
the entire dome, partially tessellate the dome and find neighbouring vertices.
The library provides various powerful commands to enable these functions through
a user-facing class wrapper.The library prioritises efficiency by compiling throughNumba.InstallationTo install our library please use the following command:$ pip install geodomeBasic UsageAn example of how to instantiate a Geodesic Dome class can be found below:fromgeodomeimportGeodesicDomegd=GeodesicDome()# Futher operations hereDocumentation for the available class wrapper and its related methods can be
foundhere.This python library was created as a University of Sydney capstone unit under
the direction of the School of Computer Science