Saravanan666/pypi-org huggingface dataset:
Package: urb
urburb is a dank cli dictionary to quickly search up definitions from Urban Dictionary and GoogleIt is primarily supposed to be used from the terminal, and can also be used as a python module to use the Urban Dictionary and Google dictionay APIs and much moreThe CLI offers a lot of fun amusing commands to fulfill your vocabulary needs from the convinience of the terminal.Installationpip install urbcommandsdefinePulls up the definition for a word. the word to be searched is given as an argument to this command. Urb searches words on urban dicitonary by defaulturb define hellofetch search results from Google dictionary instead \urb define -g hello
  
  urb define --google helloSpecify the result to display out of multiple definitions fetched from the resources. There can be multiple definitions for a single word, use this option to choose which definition gets displayed. This option takes a number as an argument.urb define -i 3 hello

  urb define --index 3 hellorandomGet's the definition of a random word. This commands takes no arguments and has no options.urb randomspelluse this commands to verify if a spelling is correct. urb offers corrections is a spelling is wrong. This commands takes a word as an argument and has no options.urb spell conviniencewotdGet a word of the day.urb wotdSpecify the result to display out of multiple definitions fetched from the resource. There can be multiple multiple words of the day, use this option to choose which definition gets displayed. This option takes a number as an argument.urb wotd -i 3

  urb wotd --index 3quotefetch a random quoteurb quote
Package: urbackup-server-web-api-wrapper
urbackup-server-web-api-wrapperPython wrapper to access and control an UrBackup serverInstallationInstall with:pip3 install urbackup-server-web-api-wrapperUsageStart a full file backup:importurbackup_apiserver=urbackup_api.urbackup_server("http://127.0.0.1:55414/x","admin","foo")server.start_full_file_backup("testclient0")List clients with no file backup in the last three days:importurbackup_apiimporttimeimportdatetimeserver=urbackup_api.urbackup_server("http://127.0.0.1:55414/x","admin","foo")clients=server.get_status()diff_time=3*24*60*60# 3 daysforclientinclients:ifclient["lastbackup"]=="-"orclient["lastbackup"]<time.time()-diff_time:ifclient["lastbackup"]=="-"orclient["lastbackup"]==0:lastbackup="Never"else:lastbackup=datetime.datetime.fromtimestamp(client["lastbackup"]).strftime("%x%X")print("Last file backup at{lastbackup}of client{clientname}is older than three days".format(lastbackup=lastbackup,clientname=client["name"]))
Package: urbamt
URBaMT: Universal Rule-Based Machine Translation toolkitA tool for translating text from source grammar to target grammar (context-free) with corresponding dictionary.Why not translate it yourself when Google Translate cannot satisfy you❓InstallationpipinstallurbamtUsagefromurbamtimportTranslator# Source sentence to be translatedsrc_sentences=["I love good dogs","I hate bad dogs"]# Source grammar in nltk parsing stylesrc_grammar="""S -> NP VPNP -> PRPVP -> VB NPNP -> JJ NNPRP -> 'I'VB -> 'love' | 'hate'JJ -> 'good' | 'bad'NN -> 'dogs'"""# Some edit within source grammar to target grammarsrc_to_target_grammar={"NP -> JJ NN":"NP -> NN JJ"# in Vietnamese NN goes before JJ}# Word-by-word dictionary from source language to target languageen_to_vi_dict={"I":"tôi","love":"yêu","hate":"ghét","dogs":"những chú_chó","good":"ngoan","bad":"hư"}translator=Translator(src_grammar=src_grammar,src_to_tgt_grammar=src_to_target_grammar,src_to_tgt_dictionary=en_to_vi_dict)trans_sentences=translator.translate(src_sentences)# This should returns ['tôi yêu những chú_chó ngoan', 'tôi ghét những chú_chó hư']LicenseThis repository is using the Apache 2.0 license that is listed in the repo. Please take a look atLICENSEas you wish.BibTeXIf you wish to cite the framework feel free to use this (but only if you loved it 😊):@misc{phat2020urbamt,author={Patrick Phat},title={URBaMT: Universal Rule-Based Machine Translation toolkit},year={2020},publisher={GitHub},journal={GitHub repository},howpublished={\url{https://github.com/urbamt/urbamt}},}Contributors:Patrick Phat Nguyen
Package: urbanairship
urbanairshipis a Python library for using theAirshipREST API for push notifications, message
center messages, email, and SMS.RequirementsPython 2.7, 3.6, 3.7, 3.8, or 3.9 is required. Other requirements can be found in requirements.txt.QuestionsThe best place to ask questions or report a problem is our support site:http://support.airship.com/UsageSee thefull documentation for this library, as well as theAirship API Documentation.Simple iOS Push>>> import urbanairship as ua
>>> airship = ua.Airship('application_key', 'master_secret')
>>> push = airship.create_push()
>>> push.audience = ua.or_(ua.alias('adam'), ua.ios_channel('some_ios_channel'))
>>> push.notification = ua.notification(alert='Hello')
>>> push.device_types = ua.device_types('ios')
>>> push.send()Broadcast to iOS and Android devices>>> push = airship.create_push()
>>> push.audience = ua.all_
>>> push.notification = ua.notification(
...     ios=ua.ios(alert='Hello iOS'),
...     android=ua.android(alert='Hello Android'))
>>> push.device_types = ua.device_types('ios', 'android')
>>> push.send()Sending a message center message to a single iOS device>>> import urbanairship as ua
>>> airship = ua.Airship('application_key', 'master_secret')
>>> push = airship.create_push()
>>> push.audience = ua.ios_channel('some_ios_channel')
>>> push.notification = ua.notification(alert='Hello')
>>> push.device_types = ua.device_types('ios')
>>> push.message = ua.message(
...     'Hello, message center user',
...     '<html><h1>Hello!</h1><p>Goodbye.</p></html>')
>>> push.send()Web Push to a tag>>> import urbanairship as ua
>>> airship = ua.Airship('application_key', 'master_secret')
>>> push = airship.create_push()
>>> push.audience = ua.tag('web_tag')
>>> push.notification = ua.notification(alert='Hello')
>>> push.device_types = ua.device_types('web')
>>> push.send()History6.0 Support for Bearer Token Authentication. Removes support for Python 2.5.0 Support for SMS and Email messages. See changelog for other updates.4.0 Support for Automation, removed Feedback3.0 Support for Open Channels, several other significant changes2.0 Support for Web Notify and more iOS 10, stopped supporting Python 2.61.0 Support for In-App and iOS 100.8 Support for Reports APIs0.7 Support for Python 3, major refactoring0.6 Major refactoring, support for push api v30.5 Added Android, Rich Push, and scheduled notifications0.4 Added batch push0.3 Added deregister, device token list, other minor improvements0.2 Added tags, broadcast, feedback0.1 Initial releaseSee the CHANGELOG file for more details.
Package: urbanairship3
Abouturbanairship3is a Python library for using theUrban Airshipweb service API for push notifications and rich
app pages. This is a fork of originalurbanairshipwith Python 3 support.Why fork?Primarily for publishing Python 3 compatible version at PyPi for easier install.Installpip install urbanairship3RequirementsAs of version 0.6, Python 2.6+ or 3.3+ is required.FunctionalityVersion 0.6 is a major upgrade, focusing on support for the new version 3 push
API. There has also been a major reorganization of the codebase.device token registrationbasic pushregistering and pushing with tagsbroadcastfeedback servicedevice token deactivation (deregistration)device token listingrich pushscheduled notificationsUsageSee thefull documentation, as well as theUrban Airship API Documentation.Simple iOS Push>>> import urbanairship as ua
>>> airship = ua.Airship('application_key','master_secret')
>>> push = airship.create_push()
>>> push.audience = ua.or_(ua.alias('adam'), ua.device_token('some_token'))
>>> push.notification = ua.notification(alert='Hello')
>>> push.device_types = ua.all_
>>> push.send()Broadcast to iOS, Android, and BlackBerry devices>>> push = airship.create_push()
>>> push.audience = ua.all_
>>> push.notification = ua.notification(
...     ios=ua.ios(alert='Hello iOS'),
...     android=ua.android(alert='Hello Android'),
...     blackberry=ua.blackberry(alert='Hello BlackBerry'))
>>> push.device_types = ua.device_types('ios', 'android', 'blackberry')
>>> push.send()Sending a rich app page to a single iOS device>>> import urbanairship
>>> airship = urbanairship.Airship('application_key','master_secret')
>>> push = airship.create_push()
>>> push.audience = ua.device_token('some_token')
>>> push.notification = ua.notification(alert='Hello')
>>> push.device_types = ua.device_types('ios')
>>> push.message = ua.message(
...     "Hello, Rich Push User",
...     "<html><h1>Hello!</h1><p>Goodbye.</p></html>")
>>> push.send()QuestionsThe best place to ask questions is our support site:http://support.urbanairship.com/History0.1 Initial release0.2 Added tags, broadcast, feedback0.3 Added deregister, device token list, other minor improvements0.4 Added batch push0.5 Added Android, Blackberry, Rich Push, and scheduled notifications0.6 Major refactoring, support for push api v3
Package: urbandict
py-urbandictpy-urbandict is a client for urbandictionary.com.Project page on github:https://github.com/novel/py-urbandictPyPI:https://pypi.org/project/urbandict/InstallationJust run:sudo setup.py installUsageTo use it from command line, just use 'urbancli' tool like that:$ urbandicli xterm
1. xterm
  Godly creature, omnipotent, guru in every way imaginable.
  
  Examples:
  
  * I wish i was an xterm

$Usage from Python:$ python3.2
Python 3.2 (r32:88445, Feb 27 2011, 09:51:00) 
[GCC 4.2.1 20070719  [FreeBSD]] on freebsd8
Type "help", "copyright", "credits" or "license" for more information.
>>> import urbandict
>>> urbandict.define('xterm')
[{'word': 'xterm', 'example': 'I wish i was an xterm', 'def': 'Godly creature, omnipotent, guru in every way imaginable.'}]
>>>It returns list of defitinitions for a term. Each list item is a dict with the following keys:word -- the word itselfdef -- definition of the termexample -- example of its usage (could be empty)
Package: urbandictionary-python
Urban Dictionary Python (Unofficial)A Python Library To Web Scrape Urban Dictionary.InstallationUse the package managerpipto install Urban Dictionary Python.pipinstallurbandictionary_pythonUsageimporturbandictionary_pythonword=""# Enter A Word# Make An Instance :ubd=urbandictionary_python.UrbanDictionary(word)# Get Most Liked Meaning :print(ubd.meaning())# Get Most Liked Meaning's Example :print(ubd.example())# Get Most Liked Meaning's Author Name :print(ubd.author())# Get Most Liked Meaning's Publishing Date :print(ubd.publishing_date())# Get Most Liked Meaning's Mug Link :print(ubd.mug_link())# Get Most Liked Meaning's Front Mug Image :print(ubd.front_mug_image())# Get Most Liked Meaning's Back Mug Image :print(ubd.back_mug_image())# Get More Meanings List :print(ubd.more_meanings())# Get More Meanings Of Query :foriinubd.more_meanings():print(i)# Get All Meanings Of Query :foriinubd.more_meanings():print(i["meaning"])# Get All Examples Of Query :foriinubd.more_meanings():print(i["example"])# Get Every Author's Name :foriinubd.more_meanings():print(i["author"])# Get Every Meaning's Publishing Date :foriinubd.more_meanings():print(i["date"])# Get Every Meaning's Mug Back Image :foriinubd.more_meanings():print(i["mug_back_image"])ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: urban-footprinter
Urban footprinterA reusable convolution-based approach to detect urban extents from raster datasets.LULCConvolution resultComputed urban extentThe approach is built upon the methods used in theAtlas of Urban Expansion. The main idea is that a pixel is considered part of the urban extent depending on the proportion of built-up pixels that surround it. See thenotebook overvieworthis blog postfor a more detailed description of the procedure.Citation: Bosch M. 2020. "Urban footprinter: a convolution-based approach to detect urban extents from raster data". Available fromhttps://github.com/martibosch/urban-footprinter. Accessed: DD Month YYYY.An example BibTeX entry is:@misc{bosch2020urban,title={Urban footprinter: a convolution-based approach to detect urban extents from raster data},author={Bosch, Mart\'{i}},year={2020},doi={10.5281/zenodo.3699310},howpublished={Available from \url{https://github.com/martibosch/urban-footprinter}. Accessed: DD Month YYYY},}Installation and usageTo install use pip:$ pip install urban-footprinterThen use it as:importurban_footprinterasufp# Or use `ufp.urban_footprint_mask_shp` to obtain the urban extent as a# shapely geometryurban_mask=ufp.urban_footprint_mask("path/to/raster.tif",kernel_radius,urban_threshold,urban_classes=urban_classes)wherehelp(ufp.urban_footprint_mask)

Help on function urban_footprint_mask in module urban_footprinter:

urban_footprint_mask(raster, kernel_radius, urban_threshold, urban_classes=None, num_patches=1,
                     buffer_dist=None, res=None)
    Computes a boolean mask of the urban footprint of a given raster.

    Parameters
    ----------
    raster : ndarray or str, file object or pathlib.Path object
        Land use/land cover (LULC) raster. If passing a ndarray (instead of the
        path to a geotiff), the resolution (in meters) must be passed to the
        `res` keyword argument.
    kernel_radius : numeric
        The radius (in meters) of the circular kernel used in the convolution.
    urban_threshold : float from 0 to 1
        Proportion of neighboring (within the kernel) urban pixels after which
        a given pixel is considered urban.
    urban_classes : int or list-like, optional
        Code or codes of the LULC classes that must be considered urban. Not
        needed if `raster` is already a boolean array of urban/non-urban LULC
        classes.
    num_patches : int, default 1
        The number of urban patches that should be featured in the returned
        urban/non-urban mask. If `None` or a value lower than one is provided,
        the returned urban/non-urban mask will featuer all the urban patches.
    buffer_dist : numeric, optional
        Distance to be buffered around the urban/non-urban mask. If no value is
        provided, no buffer is applied.
    res : numeric, optional
        Resolution of the `raster` (assumes square pixels). Ignored if `raster`
        is a path to a geotiff.

    Returns
    -------
    urban_mask : ndarray
Package: urbangrammar-graphics
Urban Grammar AI graphicsVisual style for Urban Grammar AI research projectSee the Jupyter notebook inexamplesfor an illustration of usage.Available visual presets:RGB- 0-256 RGB codesCOLORS- 0-1 RGB codesHEX- HEX codes (['#333432', '#3b6e8c', '#bc5b4f', '#8fa37e', '#efc758', '#94666e'])DIVERGING- diverging seaborn paletteDIVERGING_MPL- diverging matplotlib paletteCMAP- matplotlib colormap (6 primary colors)get_colormap(n=18, randomize=True)- Get expanded colormapget_tiles(tiles, token)- Get links to Mapbox tiles.tilescan be"roads","labels"or"background"north_arrow(f, ax, rotation=0, loc="upper left", size=0.02, linewidth=3, color="k", pad=0, alpha=1,)- Create north arrownorth_arrow parameters
----------------------

f : figure

ax: axis

rotation : float
    rotation of an arrow (in case map is rotated)

loc : string
    location of an arrow

size : float
    float denoting the length/width in terms
    of a fraction of the axis.

linewidth : float
    linewidth

color : string
    color of an arrow

pad : float
    additional padding

alpha : float
    alpha
Package: urbanlivabilityscore
UrbanLivabilityScoreInstalling the package:pipinstallurbanlivabilityscoreSyntaxstreet_lighting_score(road_width,number_of_poles)# road_width and number_of_poles are expected to be arraysFew ways of using the packagefromurbanlivabilityscoreimportstreet_lighting_scorestreet_lighting_score(road_width,number_of_poles)fromurbanlivabilityscoreimportstreet_lighting_scoreasslssls(road_width,number_of_poles)importurbanlivabilityscoreurbanlivabilityscore.street_lighting_score(road_width,number_of_poles)importurbanlivabilityscoreasulsuls.street_lighting_score(road_width,number_of_poles)
Package: urbanopti
Urban OptimizerThis module finds the optimal configuration of a sustainable mobility system that integrates bicycle trails, canals and railways. It was created at the Department of Electronics, Information, and Bioengineering (DEIB) of the Politecnico di Milano. It provides decision-makers with a tool for urban planning that takes into account all aspects of multi-modal mobility and guarantees optimality of the solution w.r.t. a user-defined criterion: minimum cost, maximum routed traffic, maximum routed origin/destination pairs, among others.The module is implemented as a Python package that can be imported withimport urbanopti. It can be used in conjunction with theUrban Optimizer Plugin, which can be accessed through QGIS. Usage of the Python moduleurbanoptirequires installation of modulesmip,numpy, andscipy.(C) Politecnico di Milano, 2021-2022.
Package: urbanpython
urbanpythonurbanpython is an API wrapper for the Urban Dictionary JSON APIInstallationTo install urbanpy, do:pip install urbanpythonorpython -m pip install urbanpythonDocumentationThis README file is the documentationExamplesTo get your API key, go tohttps://rapidapi.com/community/api/urban-dictionary/endpointsand get your API keyimporturbanpythonurban=urbanpython.Urban("-your api key-")result=urban.search("the thing you are gonna search")print(result.definition)#Definition of the postprint(result.permalink)#The link to the postprint(result.thumbs_up)#Number of thumbs upsprint(result.thumbs_down)#Number of thumbs downsprint(result.sounds_url)#A list of the sounds urls in the postprint(result.author)#The author of the postprint(result.defid)#The ID of the definitionprint(result.written_on)#The time the definition got written onprint(result.example)#The example of the post
Package: urban.restapi
Tell me what your product doesFeaturesCan be bullet pointsExamplesThis add-on can be seen in action at the following sites:
- Is there a page on the internet where everybody can see the features?DocumentationFull documentation for end users can be found in the “docs” folder, and is also available online athttp://docs.plone.org/foo/barTranslationsThis product has been translated intoKlingon (thanks, K’Plai)InstallationInstall urban.restapi by adding it to your buildout:[buildout]

...

eggs =
    urban.restapiand then runningbin/buildoutContributeIssue Tracker:https://github.com/collective/urban.restapi/issuesSource Code:https://github.com/collective/urban.restapiDocumentation:https://docs.plone.org/foo/barSupportIf you are having issues, please let us know.
We have a mailing list located at:project@example.comLicenseThe project is licensed under the GPLv2.ContributorsJulien Jaumotte,julien.jaumotte@imio.beChangelog1.0.0b6 (2024-02-08)Fix endpoint address for fail street code search [MURBFMAA-20]
[jchandelle]1.0.0b5 (2024-02-05)Add possibility to search street with code in @address
[jchandelle]1.0.0b4 (2023-11-06)Fix street search to include disable street
[jchandelle]1.0.0b3 (2023-09-19)Add imio.restapi dependency
[jchandelle]Adapt street retrieval key [SUP-31682]
[jchandelle]1.0.0b2 (2023-07-24)Fix multiresult in street search with exact match [URB-2696]
[jchandelle]1.0.0b1 (2023-06-29)Fix POST endpoint for event creation [URB-2730]
[jchandelle]Add utils for getting config object from a path
[jchandelle]Fix address query with parenthesis [URB-2696]
[jchandelle]1.0a1 (2023-04-05)Initial release.
[jjaumotte]
Package: urbans
URBANS: Universal Rule-Based Machine Translation toolkitA tool for translating text from source grammar to target grammar (context-free) with corresponding dictionary.Why not translate it yourself when Google Translate cannot satisfy you❓⚙️ Installationpipinstallurbans✨ What is good about urbans?Rule-based, deterministic translation; unlike Google Translate - giving only 1 non-deterministic resultUsing NLTK parsing interface and is built on top of already-efficient NLTK backendCan be used for data augmentation📖 UsagefromurbansimportTranslator# Source sentence to be translatedsrc_sentences=["I love good dogs","I hate bad dogs"]# Source grammar in nltk parsing stylesrc_grammar="""S -> NP VPNP -> PRPVP -> VB NPNP -> JJ NNPRP -> 'I'VB -> 'love' | 'hate'JJ -> 'good' | 'bad'NN -> 'dogs'"""# Some edit within source grammar to target grammarsrc_to_target_grammar={"NP -> JJ NN":"NP -> NN JJ"# in Vietnamese NN goes before JJ}# Word-by-word dictionary from source language to target languageen_to_vi_dict={"I":"tôi","love":"yêu","hate":"ghét","dogs":"những chú_chó","good":"ngoan","bad":"hư"}translator=Translator(src_grammar=src_grammar,src_to_tgt_grammar=src_to_target_grammar,src_to_tgt_dictionary=en_to_vi_dict)trans_sentences=translator.translate(src_sentences)# This should returns ['tôi yêu những chú_chó ngoan', 'tôi ghét những chú_chó hư']⚖️ LicenseThis repository is using the Apache 2.0 license that is listed in the repo. Please take a look atLICENSEas you wish.✍️ BibTeXIf you wish to cite the framework feel free to use this (but only if you loved it 😊):@misc{phat2020urbans,author={Truong-Phat Nguyen},title={URBANS: Universal Rule-Based Machine Translation NLP toolkit},year={2021},publisher={GitHub},journal={GitHub repository},howpublished={\url{https://github.com/pyurbans/urbans}},}Contributors:Patrick Phat Nguyen
Package: urban-scraper
Asynchronous and Synchronous Urban Dictionary ScraperIt usesselectolaxto parse the HTML andhttpxfor sending HTTP requests.Asynchronous Exampleimportasynciofromurban_scraperimportadefineasyncdefmain():definitions=awaitadefine('hello')asyncfordefinitionindefinitions:...asyncio.run(main())Synchronous Examplefromurban_scraperimportdefinedefinitions=define('hello')fordefinitionindefinitions:...In both examples,definitionisurban_scraper.DefinitionAttributes and Methods ofurban_scraper.DefinitionAttributesdefidnamemeaningexampleauthornameurldateupvotedownvoteMethodsas_dict()Converts the dataclass to adictobject and returns it.How To InstallUsing pip:pip install urban-scraperManual:Clone the folder somewhereCD to the locationInstall the packages listed inrequirements.txt(pip install -r requirements.txt)Copy the folder,urban_scraperwhere you want to use it.
Package: urbansim
UrbanSim is a platform for building statistical models of cities and regions. These models help forecast long-range patterns in real estate development, demographics, and related outcomes, under various policy scenarios.ThisurbansimPython library is a core component. It contains tools for statistical estimation and simulation; domain-specific logic about housing markets, household relocation, and other processes; and frameworks and utilities for assembling a model.How it worksOperational UrbanSim models begin with detailed data about a particular region, and then estimate and validate a system of interconnected model components. Full models draw on a number of libraries: not justurbansim, but alsoOrcafor task orchestration,Synthpopfor population synthesis,Pandanafor network analysis, and so on. Collectively, these make up theUrban Data Science Toolkit(UDST).UrbanSim models are used by public agencies, consultancies, and researchers in dozens of cities around the U.S. and world. The core platform is open source, but many operational models make use of additional cloud-hosted model building and visualization tools provided byUrbanSim Inc.Learn MoreAn Introduction to UrbanSimUrbanSim for San Francisco: An example implementationUrbanSim Inc.Installationpip install urbansimconda install urbansim--channelconda-forgeTechnical documentationGetting startedFull documentationOtherUDSTlibrariesDocumentation forUrbanCanvas, the UrbanSim cloud platform