Saravanan666/pypi-org huggingface dataset:
Package: geoflow-capability-search
Running in dev-modeCreate a new Python virtual environment for the template:$ cd template
$ python3 -m venv venv  # create venv
$ . venv/bin/activate   # activate venv
$ pip install streamlit # install streamlitInitialize and run the component template frontend:$ cd template/my_component/frontend
$ npm install    # Install npm dependencies
$ npm run start  # Start the Webpack dev serverFrom a separate terminal, run the template's Streamlit app:$ cd template
$ . venv/bin/activate  # activate the venv you created earlier
$ streamlit run my_component/__init__.py  # run the examplestreamlit-custom-componentStreamlit component that allows you to do XInstallation instructionspipinstallgeoflow-capability-searchUsage instructionsimportstreamlitasstfrommy_componentimportmy_componentvalue=my_component()st.write(value)Component receives 3 callback functions - make sure to pass it to receive the values from the componentSearch - triggers when search is being performedSubmit - triggers when user clicks "Suggest" for capabilitiesDetails - when user clicks particular capability and request for related terms and description is being firedPuslishingTo publish component to pipmake sure to check:init.py that the app is pointing to the build file and not localhostsetup.py that the version is updatedchange _RELEASE variablepush the lates version to maincreate release in the githubNew pypi release will be created automaticallyComponent APIComponent has 4 types of action:Search - triggers when search is being performedSubmit - triggers when user clicks "Suggest" for capabilitiesDetails - when user clicks particular capability and request for related terms and description is being firedReset - when user resets the autocomplete value
Package: geofound
geofoundA Python package to assess the settlement and bearing capacity of foundations.How to UseThe geofound package relies on two main Objects, the Foundation object and the Soil object.These objects are inherited from the sfsimodels python module.Examplesimportgeofoundimportgeofound.settlementimportgeofound.capacitylength=21.7width=1.5# metresdepth=1.5# metresphi=38cohesion=0unit_weight=18.5# submergedyoungs_modulus_soil=30000fd=geofound.create_foundation(length,width,depth)sl=geofound.create_soil(phi,cohesion,unit_weight)sl.unit_sat_weight=18.5q_lim=geofound.capacity.capacity_vesics_1975(sl,fd)p_max=q_lim*length*widthprint(' ')print('Ultimate bearing stress is q_lim = '+str(round(q_lim,0))+' kPa')print('Ultimate load is Q_lim = '+str(round(p_max,0))+' kN')and for settlement.load=21484s=geofound.settlement.settlement_schmertmann(sl,fd,load,youngs_modulus_soil)print(' ')print('Settlement is si = '+str(round(s,2))+' m')Useful materialhttp://geo.cv.nctu.edu.tw/foundation/download/BearingCapacityOfFoundations.pdfhttp://geo.cv.nctu.edu.tw/foundation/download/FoundationsSettlements.pdfhttp://geo.cv.nctu.edu.tw/foundation/download/SchmertmannMethod.pdfhttp://www.civil.utah.edu/~bartlett/CVEEN5305/Handout%206%20-%20Schmertmann%20CPT%20method%20Example.pdf
Package: geog0111
GEOG0111 Scientific ComputingCourse DocumentationCourse informationCourse ConvenorProf P. LewisTeaching Staff 2020-2021Prof P. LewisDr Qingling WuContributing StaffDr Qingling WuDr. Jose Gomez-DansFeng YinPurpose of this courseThis course, GEOG0111 Scientific Computing, is a term 1 MSc module worth 15 credits (25% of the term 1 credits) that aims to:impart an understanding of scientific computinggive students a grounding in the basic principles of algorithm development and program constructionto introduce principles of computer-based image analysis and model developmentIt is open to students from a number of MSc courses run by the Department of Geography UCL, but the material should be of wider value to others wishing to make use of scientific computing.The module will cover:Computing in PythonComputing for image analysisComputing for environmental modellingData visualisation for scientific applicationsLearning OutcomesAt the end of the module, students should:have an understanding of the Python programmibng language and experience of its usehave an understanding of algorithm development and be able to use widely used scientific computing software to manipulate datasets and accomplish analytical taskshave an understanding of the technical issues specific to image-based analysis, model implementation and scientific visualisationRunning on UCL JupyterHubFollow the instructions onUCL installation and runningTimetableclass timetable for 2020/21The course takes place over 10 weeks in term 1, usually in the Geography Department Unix Computing Lab (PB110) in theNorthwest wing, UCL.Due to covid restrictions, it is being run online in the 2020-21 session.Classes take place from the second week of term to the final week of term, other than Reading week. See UCLterm datesfor further information.The timetable is available on the UCL Academic Calendar. Live class sessions will take place in groups on Monday and Thursdays.AssessmentAssessment is through two pieces of coursework, submitted in both paper form and electronically via Moodle.See theMoodle pagefor more details.Useful linksCourse Moodle pageNotes, code etcgeog0111 code pypi for v1.1.0Using the course notesWe will generally usejupyternotebooks for running interactive Python programs. If you are taking this course at UCL,
follow the instructions onUCL installation and running. If you are running from outside UCLsee these notes.
Package: geoget
GeoGetUtility functions to download geo data.Installpip install geogetHow to useGo tohttps://ladsweb.modaps.eosdis.nasa.gov/and create an account and an authentication token. Then create~/.ladswebfile with the following format where you should write your email and token (key):# To create an account and an authentication token visit ladsweb website.{"url":"https://ladsweb.modaps.eosdis.nasa.gov","key":"","email":""}The following bash script shows an example of how to make a request:#!/bin/bash -lbbox='-10 36 0 44'product="NPP_VMAES_L1"collection="5000"tstart="2017-10-27 00:00:00"tend='2017-10-27 23:59:59'path_save="/srv/geoget/data"bands="Reflectance_M5 Reflectance_M7 Reflectance_M10 Radiance_M12 Radiance_M15 SolarZenithAngle SatelliteZenithAngle"geoget_ladsweb$product$collection"$tstart""$tend""$bbox"$path_save"$bands"--repName"GEO"--repPixSize"0.01"--daynight"D"In case you need to stop the request (it may take a while until the files are available) you can later callgeoget_order_manager  .onpath_savedirectory and all requests in the log file will continue to be processed.Note:Library under development. Examples above were tested in Ubuntu 16.04 LTS.
Package: geogetter
GeoGetterGeoGetter is a simple Python library and command-line tool that helps you retrieve geographic information for a given location using various APIs. Whether you need latitude and longitude coordinates, address details, or timezone information, GeoGetter has got you covered.FeaturesRetrieve latitude and longitude coordinates for a location.Get detailed address information (country, city, postal code, etc.).Fetch timezone data for a specific location.Easy-to-use Python library with a command-line interface.GitHub repository🔗geogetter GitHub repoInstallationYou can install GeoGetter using pip (consider using venv):pipinstallgeogetterUsing geogetterfromgeogetterimportGeocodereaster_island=Geocoder("Easter Island")print(easter_island.lat,easter_island.lon)Running this script should result in this output-27.1259451 -109.34963353785872It's also possible to get more detailed information about the target
using following code:fromgeogetterimportGeocoderbig_ben=Geocoder("Big Ben",address_json=True)print(big_ben.target_name,"\n")foriteminbig_ben.address_json:print(f"{item}:{big_ben.address_json.get(item)}")This should result in the following std out:Big Ben, Bridge Street, Westminster, Millbank, City of Westminster, Greater London, England, SW1A 2JX, United Kingdomamenity: Big Benroad: Bridge Streetquarter: Westminstersuburb: Millbankcity: City of WestminsterISO3166-2-lvl8: GB-WSMstate_district: Greater Londonstate: EnglandISO3166-2-lvl4: GB-ENGpostcode: SW1A 2JXcountry: United Kingdomcountry_code: gb
Package: geogif
GeoGIFMake GIFs from time-stackedxarray.DataArrays (time, [optionalband],y,x), dead-simple.fromgeogifimportgif,dgifgif(data_array)dgif(dask_data_array).compute()The "geo" part is a lie, actually. The arrays don't have to be geospatial in nature. But I called it GeoGIF because:Wanting to animate a time-stack of imagery (like you'd get fromstackstac) is a common task in the earth-observation/geospatial world.I thinkGeoGIFis a hilarious idea1.1: To ruin the joke, it sounds like GeoTIFF, a ubiquitous geospatial image format. If you also think this is a funny idea, and believe you'd have a better use for the name than I do, I'd happily cede it to you.InstallationpipinstallgeogifDocumentationSeehttps://geogif.readthedocs.io/en/latest/.DevelopmentGeoGIF is managed byPoetry, so be sure that's installed first. To develop locally, first fork or clone the repo. Then, to set up a virtual environment and install the necessary dependencies:cdgeogif
poetryinstallRunning TestsGeoGIF has some basic end-to-end tests, written withHypothesis. To run:pytestThis will take ~30 seconds (longer the first time), as Hypothesis generates fake data to root out possible errors.Code styleGeoGIF is formatted withshed, in order to allow for as few opinions as possible.
Package: geoglows
GEOGloWSVisit the Conda Forge pagecondainstall-cconda-forgegeoglowsAlso available on pypiVisit the PyPi pagepipinstallgeoglowsTools to access and process data coming from the GEOGloWS initiative.https://geoglows.readthedocs.ioThe sample data are from ReachID 13073600 which is on the mississippi river
Package: geograph
Table of contents:DescriptionInstallationRequirementsDocumentation1. DescriptionGeoGraph provides a tool for analysing habitat fragmentation and related problems in landscape ecology. GeoGraph builds a geospatially referenced graph from land cover or field survey data and enables graph-based landscape ecology analysis as well as interactive visualizations. Beyond the graph-based features, GeoGraph also enables the computation of common landscape metrics.2. InstallationGeoGraph is available via pip, so you can install it usingpip install geographDone, you're ready to go!You can also visit theGithub repository.See thedocumentationfor a full getting started guide or check out thebinderfor tutorials on how to get started .3. RequirementsGeoGraph is written in Python 3.8 and builds onNetworkX,ipyleaflet,geopandas,rasterioand many more packages. See therequirements directoryfor a full list of dependencies.4. DocumentationOur documentation is available atgeograph.readthedocs.io.
Package: geographica-longitude
LongitudeAnewbunch of middleware functions to build applications on top of CARTO.RoadmapDatabase modelCARTO data sourceBasic parametrized queries (i.e. templated queries)Protected parametrized queries (i.e. avoiding injection)Bind/dynamic parameters in queries (server-side render)Postgres data sourcepsycopg2SQLAlchemyCacheBase cachePutGetKey generationFlushTestsRam CacheTestsRedis CacheTestsDocumentationSample scriptsUnit testsSample scriptsConfigCI PyPi versioningCOPY operationsCartoCOPY FROMCOPY TOPostgresCOPY FROMCOPY TOSQLAlchemyCOPY FROMCOPY TOValidationsMarshmallowWrapper (?)DocumentationSwaggerDecoratorsFlassger (?)OAuth integrationPostman integrationDocumentationSQL AlchemyModel definitionJenkins integrationDocumentationOAuthOAuth2 with Carto (onprem)Role mappingToken storageDocumentationAs final user...How to use:pipinstalllongitudeOr:pipenvinstalllongitudeOr:poetryaddlongitudeOr install from GitHub:pipinstall-egit+https://github.com/GeographicaGS/Longitude#egg=longitudeAs developer...First timeInstallpoetryusing therecommended processpoetry is installed globally as a toolIt works along with virtualenvironmentsCreate a virtual environment for Python 3.x (check the current development version inpyproject.toml)You can create it wherever you want but do not put it inside the projectA nice place is$HOME/virtualenvs/longitudeClone thelongituderepocdto the repo and:Activate the virtual environment:. ~/virtualenvs/longitude/bin/activateRunpoetry installConfigure your IDE to use the virtual environmentDailyRemember to activate the virtual environmentWhy Poetry?Because it handles development dependencies and packaging with a single file (pyproject.toml), which isalready standard.Sample scriptsThese are intended to be used with real databases (i.e. those in your profile) to check features of the library. They must be run from the virtual environment.Testing and coverageThepytest-covplugin is being used. Coverage configuration is at.coveragerc(including output folder).You can run something like:pytest --cov-report=html --cov=core coreand the results will go in the defined html folder.There is a bash script calledgenerate_core_coverage.shthat runs the coverage analysis and shows the report in your browser.
Package: geographica-longitude-async
# Longitude-asyncA bunch of middleware functions to build applications on top of CARTO.How to use:` pip installgeographica-longitude-async`Or install from GitHub:` pip install-egit+https://github.com/GeographicaGS/Longitude-async#egg=geographica-longitude-async`BoilerplateThis repository [GeographicaGS/Longitude-async-boilerplate](https://github.com/GeographicaGS/Longitude-async-boilerplate) contains a template project (a.k.a. boilerplate) usingLongitude-async.
Package: geographiclib
Python implementation of the geodesic routines in GeographicLibThis is a library to solve geodesic problems on an ellipsoid model of
the earth.Licensed under the MIT/X11 License; seeLICENSE.txt.The algorithms are documented inC. F. F. Karney,Algorithms for geodesics,
J. Geodesy87(1), 43–55 (2013);Addenda.The documentation for this package is inhttps://geographiclib.sourceforge.io/Python/doc
Package: geographic-line-of-sight
OverviewThis application allows the user to batch process multiple line of sight queries and output them in graphical form,
using data from the Google Elevation API. A .kml file is also produced for viewing in Google Earth.HistoryI wrote this application after being frustrated at the lack of simple, free tools for processing large batches of line
of sight calculations. I watched a co-worker spend an entire shift re-entering the same data again and again over 100
hundred times and save the output as a screenshot which then had to be cropped in MS paint.Originally it was used to compare airport radars to proposed wind turbine developments however I have modified the
original to be used for any generic location or object you desire. I hope this helps someone out.InstallationCloninggit clone https://github.com/MHenderson1988/line-of-sight-analysis.gitRun main/view/gui.py and follow the on-screen instructions.Before you startTo run the application, in it's current form, you will require -A valid 'Google Elevation API' key2x Valid .csv filesValid CRS (Coordinate reference systems)Currently the application can convert between the following -Decimal latitude/longitudeEastings and Northings (OSBG36)Example .csv file.csv files must use valid headers of -latitude/eastinglongitude/northingheightnameThe above example uses decimal latitude/longitude.Row 1 - Latitude (Float)
Row 2 - Longitude (Float)
Row 3 - Height, in metres (int/float)
Row 4 - Unique name (String)Example outputGraphical output will look like this -The green line shows the path taken between the top point of the first and second locations. Below is the imposed
elevation data which has been manipulated to the simulated curvature of the earth (shown by the orange arc).The plotted line which illustrates the line of sight will be coloured green if line of sight exists. If a disruption to
the view is detected then the line will be coloured red.Current limitationsCurrently the application has the following limitations -Earth curvature is calculated, assuming that the Earth is a perfect sphereOnly Google Elevation API is currently supportedOnly natural terrain is accounted for. This application does not take foliage or man-made objects/buildings into
account
Package: geography
Geography ModuleDescriptionThis Python module, Geography, provides classes that encapsulate information about geographical entities such as countries, states/provinces, continents, and regions. These classes retrieve various geographical and socioeconomic data attributes.InstallationTo use this module, follow these steps:1. Open a terminal window and type the following command:2.pip install geography3. Enjoy!UsageClasses:AustralianState: Represents an Australian state with various attributes such as area, population, GDP, etc.CanadianProvince: Represents a Canadian province with attributes similar toAustralianState.Continent: Represents a continent with attributes like total area, population, GDP, etc.Country: Represents a country with a wide range of attributes including area, population, GDP, etc.CountrySimple: A simplified version ofCountryclass with essential attributes.USState: Represents a state within the United States with attributes similar toAustralianState.USRegion: Represents a region within the United States with attributes similar toContinent.How to Use:1. Import the desired class fromGeography.import geography2. Instantiate the class with a specific identifier (alpha code).country = geography.fetch_country('USA')3. Access various attributes of the instantiated object.print(country.name)Available subdivisions:Australian States and TerritoriesCanadian Provinces and TerritoriesContinentsCountriesUSA States and TerritoriesUSA RegionsPlanned upcoming subdivisions:Brazil StatesChina ProvincesEthiopia RegionsFrance RegionsGermany StatesIndia States and TerritoriesJapan PrefecturesMexican StatesRussia Federal SubjectsSaudi Arabia ProvincesSouth African ProvincesSpain RegionsUnited Arab Emirates - EmiratesThe information you can get:Alpha Code For Subdivisions(ISO 3166-2)Alpha-2 Code(ISO 3166-1 alpha-2)Alpha-3 Code(ISO 3166-1 alpha-3)Area in KMArea in MilesArea RankingArea Ranking DictionaryCapitalContinentCountries in ContinentFlag URLGDPGDP RankingGDP Ranking DictionaryGDP per CapitaGDP per Capita RankingGDP per Capita Ranking DictionaryLargest CityNameRegionPopulationPopulation RankingPopulation Ranking DictionaryPopulation Density in KMPopulation Density in MilesPopulation Density RankingPopulation Density Ranking DictionaryStates in RegionGet is State/Province/Territory type. (AST, CPT, SAP, UST)NoteThis module relies on external data sources and APIs for retrieving geographical and socioeconomic information. Ensure a stable internet connection for seamless functionality.For detailed information on available attributes and methods for each class, refer to the class definitions in the main file.
Package: geograpy
Extract place names from a URL or text, and add context to those names
– for example distinguishing between a country, region or city.Install & SetupGrab the package usingpip(this will take a few minutes)pip install geograpyGeograpy usesNLTKfor entity recognition, so
you’ll also need to download the models we’re using. Fortunately there’s
a command that’ll take care of this for you.geograpy-nltkBasic UsageImport the module, give some text or a URL, and presto.import geograpy
url = 'http://www.bbc.com/news/world-europe-26919928'
places = geograpy.get_place_context(url=url)Now you have access to information about all the places mentioned in the
linked article.places.countriescontains a list of country namesplaces.regionscontains a list of region namesplaces.citiescontains a list of city namesplaces.otherlists everything that wasn’t clearly a country,
region or cityNote that theotherlist might be useful for shorter texts, to pull
out information like street names, points of interest, etc, but at the
moment is a bit messy when scanning longer texts that contain possessive
forms of proper nouns (like “Russian” instead of “Russia”).But Wait, There’s MoreIn addition to listing the names of discovered places, you’ll also get
some information about the relationships between places.places.country_regionsregions broken down by countryplaces.country_citiescities broken down by countryplaces.address_stringscity, region, country strings useful for
geocodingLast But Not LeastWhile a text might mention many places, it’s probably focused on one or
two, so Geograpy also breaks down countries, regions and cities by
number of mentions.places.country_mentionsplaces.region_mentionsplaces.city_mentionsEach of these returns a list of tuples. The first item in the tuple is
the place name and the second item is the number of mentions. For
example:[('Russian Federation', 14), (u'Ukraine', 11), (u'Lithuania', 1)]If You’re Really SeriousYou can of course use each of Geograpy’s modules on their own. For
example:from geograpy import extraction

e = extraction.Extractor(url='http://www.bbc.com/news/world-europe-26919928')
e.find_entities()

# You can now access all of the places found by the Extractor
print e.placesPlace context is handled in theplacesmodule. For example:from geograpy import places

pc = places.PlaceContext(['Cleveland', 'Ohio', 'United States'])

pc.set_countries()
print pc.countries #['United States']

pc.set_regions()
print pc.regions #['Ohio']

pc.set_cities()
print pc.cities #['Cleveland']

print pc.address_strings #['Cleveland, Ohio, United States']And of course all of the other information shown above
(country_regionsetc) is available after the correspondingset_method is called.CreditsGeograpy uses the following excellent libraries:NLTKfor entity recognitionnewspaperfor text
extraction from HTMLjellyfishfor fuzzy
text matchpycountryfor
country/region lookupsGeograpy uses the following data sources:GeoLite2for city
lookupsISO3166ErrorDictionaryfor common country mispellingsvia `Sara-Jayne
Terp <https://github.com/bodacea>`__Hat tip toChris Albonfor the name.
Package: geograpy2
Extract place names from a URL or text, and add context to those names – for
example distinguishing between a country, region or city.## Install & SetupGrab the package usingpip(this will take a few minutes)pip install geograpy2Geograpy2 uses [NLTK](http://www.nltk.org/) for entity recognition, so you’ll also need
to download the models we’re using. Fortunately there’s a command that’ll take
care of this for you.geograpy-nltk## Basic UsageImport the module, give some text or a URL, and presto.import geograpy2
url = ‘http://www.bbc.com/news/world-europe-26919928’
places = geograpy2.get_place_context(url=url)## CreditsGeograpy2 is a fork of [geograpy](https://github.com/ushahidi/geograpy) and inherits
most of it, but solves several problems (such as support for utf8, places names
with multiple words, confusion over homonyms etc).Geograpy2 uses the following excellent libraries:[NLTK](http://www.nltk.org/) for entity recognition[newspaper](https://github.com/codelucas/newspaper) for text extraction from HTML[jellyfish](https://github.com/sunlightlabs/jellyfish) for fuzzy text match[pycountry](https://pypi.python.org/pypi/pycountry) for country/region lookupsGeograpy uses the following data sources:[GeoLite2](http://dev.maxmind.com/geoip/geoip2/geolite2/) for city lookups[ISO3166ErrorDictionary](https://github.com/bodacea/countryname/blob/master/countryname/databases/ISO3166ErrorDictionary.csv) for common country mispellings _via [Sara-Jayne Terp](https://github.com/bodacea)_Hat tip to [Chris Albon](https://github.com/chrisalbon) for the name.Released under the MIT license.
Package: geogrid-dask
Geogrid DaskFeaturesTODORequirementsTODOInstallationYou can installGeogrid DaskviapipfromPyPI:$pipinstallgeogrid-daskUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theGPL 3.0 license,Geogrid Daskis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.