Saravanan666/pypi-org huggingface dataset:
Package: guichet
GuichetQuickly create simple GUIs in Python.defhappy_text(text:str,feeling_happy:bool):iffeeling_happy:returntext+"!!!"else:returntextgui=Guichet(happy_text)gui.render()The code above renders the following GUI:You can also customize the layout by accessing thelayoutattribute of theGuichetobject.GUI controls are rendered according totype hints. Supported types include vanilla Python types (such asstr,intandfloat), types fromtyping(such asLiteral) andPydantic types(such asSecretStr).The full conversion table is as follows:Type hintGUI controlRendered asstrText inputintText inputfloatText inputboolCheckboxpydantic.SecretStrPassword inputtyping.Literalwith args (for exampleLiteral["Option 1", "Option 2"])DropdownGuichet is based on the awesomePySimpleGUIlibrary.Installationpip install guichetMain APIGuichet(
    main_function: Callable,
    title: str = None,
    output_size: tuple = (80, 20),
    button_label: str = "Run",
    theme: str = "Dark Blue 3",
    show_default: bool = True,
    ignore_params: list = None,
    redirect_stdout: bool = True,
    run_in_new_thread: bool = False,
    wait_message: str = "Please wait...",
    refresh_time: int = 1000,
    window_param: str = None,
)main_function(Callable): The function in which the GUI is based on.title(str, optional): The window title. Defaults toNone, which means the name of themain_functionwill be used.output_size(tuple, optional): The size of the output field, which indirectly sets the size of the window. Defaults to(80, 20).button_label(str, optional): The label of the button that callsmain_function. Defaults to"Run".theme(str, optional): The window theme. You can explore the list of available themes following theseinstructions. Defaults to"Dark Blue 3".show_default(bool, optional): Whether to show the default values of the parameters in the GUI. Defaults toTrue.ignore_params(list, optional): Parameters to be ignored and not shown in the GUI. Defaults toNone.redirect_stdout(bool, optional): Whether to redirect the standard output to the GUI's output field. IfTrue, regularprintcalls inmain_functionwill write to the output field. Defaults toTrue.run_in_new_thread(bool, optional): Whether to run themain_functionin a new thread. This should only beTrueif themain_functionis slow and you want to avoid blocking the GUI. Read the docs as some caveats apply when running a function in a separate thread. Defaults toFalse.wait_message(str, optional): The message to be shown in the output field.
when a users presses the running button and the function has not yet
finished. Applicable only ifrun_in_new_threadisTrue.
Defaults to"Please wait...".refresh_time(int, optional): Time (in milliseconds) for the window to check again for new events. Useful only in advanced scenarios whererun_in_new_threadisTrue. Use the highest value you can afford. Defaults to1000.window_param(str, optional): The parameter of themain_functionto where the GUI's main window object will be passed. Needed only in advanced scenarios where themain_functionneeds to communicate with the GUI. The parameter passed towindowwill not be shown in the GUI. Defaults toNone.
Package: guidata
guidata: Automatic GUI generation for easy dataset editing and display with Pythonℹ️ Created in 2009 byPierre Raybautand maintained by thePlotPyStackorganization.OverviewTheguidatapackage is a Python library generating Qt graphical user interfaces.
It is part of thePlotPyStackproject, aiming at
providing a unified framework for creating scientific GUIs with Python and Qt.Simple example ofguidatadatasets embedded in an application window:Seedocumentationfor more details on
the library andchangelogfor recent history of changes.Copyrights and licensing:Copyright © 2023CEA,Codra,Pierre Raybaut.Licensed under the terms of the BSD 3-Clause (seeLICENSE).FeaturesBased on the Qt library,guidatais a Python library generating graphical user
interfaces for easy dataset editing and display. It also provides helpers and
application development tools for Qt (PyQt5, PySide2, PyQt6, PySide6).Generate GUIs to edit and display all kind of objects regrouped in datasets:Integers, floats, stringsLists (single/multiple choices)Dictionariesndarrays(NumPy's N-dimensional arrays)Etc.Save and load datasets to/from HDF5, JSON or INI files.Application development tools:Data model (internal data structure, serialization, etc.)Configuration managementInternationalization (gettext)Deployment toolsHDF5, JSON and INI I/O helpersQt helpersReady-to-use Qt widgets: Python console, source code editor, array editor, etc.Dependencies and installationSeeInstallationsection in the documentation for more details.
Package: guidb
Guidb is a minimal layer of code on top of Leveldb, using Google’s
protocol buffers and ZeroMQ, to build a key-value distributed
datastore.The goal of this project is more academic than practical, to prove
that key-value datastores can be distributed and scaled-up very easily
with minimal work.I honestly doubt that it will grow to a enterprise-class database
because then it will be as complex as Riak or Cassandra, and I don’t
have the time, the knowledge nor the talent to do that.If you have comments, use the comment form in my webpage for any
post. And ignore the fact that it’s in Spanish.There is no public development repository at this time because I think
that is not necessary for roughy 200 lines of code, but I could set it
up upon request.Look at the tests (test.py) for fully working examples. It’s as easy
as it gets.
Package: guid-core
GUID-coreTool to generate GUID using sha256InstallationUse the package managerpipto install GUID-core.pipinstallgenerateGUIDUsageimportgenerate_GUIDgenerate_GUID.generate_GUID(string)# returns guidfirstname=stringlastname=stringdateOfBirth=stringgender=stringgenerate_GUID.generate_GUID2(firstname,lastname,dateOfBirth,gender)# returns guidContributingPull 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: guide
guideSimple object to navigate complex python objectsTo install:pip install guideExamplesObject that provides a mapping interface to the attributes of python object.The keys will be the names of the attributes and the values will beAttrsinstances of said attributes.>>> import guide
>>> from guide import Attrs
>>> a = Attrs(guide)
>>> sorted(a)  # you would usually use ``list`` instead of ``sorted`` but the latter is used for test consistency
['Attrs', 'ObjReader', 'base', 'util']
>>> aa = a['Attrs']
>>> sorted(aa)
['get', 'head', 'items', 'keys', 'module_from_path', 'update_keys_cache', 'values']Here's how you could implement a generator of paths (tuples) of internal module of a given module:fromguideimportAttrsimportinspectdefinternal_modules(module,path=()):ifnotisinstance(module,Attrs):module=Attrs(module)prefix=module.src.__name__fork,vinmodule.items():ifinspect.ismodule(v.src)andv.src.__name__.startswith(prefix):yieldpath+(k,)yield frominternal_modules(v,path=path+(k,))>>> import guide
>>> for path in internal_modules(guide):
...     print(path)
('tools',)
('tests',)
('tests', 'simple_tests')
('base',)
('util',)Recursively collecting objects from modules, submodules, attributes...The base function for this isguide.tools.recollect.
The followingsubmodule_callablesis simply constructed fromrecollect.>>> import guide
>>> print(*sorted(set(x.__name__ for x in guide.tools.submodule_callables(guide))), sep='\n')
Attrs
ObjReader
copy_attrs
internal_modules
is_an_obj_of_module
is_hashable
not_underscore_prefixed
recollect
submodule_callables
Package: guided-filter-pytorch
[Project][Paper][arXiv][Demo][Home]Official implementation ofFast End-to-End Trainable Guided
Filter.Faster,BetterandLighterfor pixel-wise image
prediction.PaperFast End-to-End Trainable Guided FilterHuikai Wu, Shuai Zheng, Junge Zhang, Kaiqi HuangCVPR 2018Installpip install guided-filter-pytorchUsagefrom guided_filter_pytorch.guided_filter import FastGuidedFilter

hr_y = FastGuidedFilter(r, eps)(lr_x, lr_y, hr_x)from guided_filter_pytorch.guided_filter import GuidedFilter

hr_y = GuidedFilter(r, eps)(hr_x, init_hr_y)from guided_filter_pytorch.guided_filter import ConvGuidedFilter

hr_y = ConvGuidedFilter(r, norm)(lr_x, lr_y, hr_x)Citation@inproceedings{wu2017fast,
  title     = {Fast End-to-End Trainable Guided Filter},
  author    = {Wu, Huikai and Zheng, Shuai and Zhang, Junge and Huang, Kaiqi},
  booktitle = {CVPR},
  year = {2018}
}
Package: guided-filter-tf
[Project][Paper][arXiv][Demo][Home]Official implementation ofFast End-to-End Trainable Guided
Filter.Faster,BetterandLighterfor image processing and dense
prediction.PaperFast End-to-End Trainable Guided FilterHuikai Wu, Shuai Zheng, Junge Zhang, Kaiqi HuangCVPR 2018Installpip install guided-filter-tfUsagefrom guided_filter_tf.guided_filter import fast_guided_filter

hr_y = fast_guided_filter(lr_x, lr_y, hr_x, r, eps, nhwc)from guided_filter_tf.guided_filter import guided_filter
hr_y = guided_filter(hr_x, init_hr_y, r, eps, nhwc)Citation@inproceedings{wu2017fast,
  title     = {Fast End-to-End Trainable Guided Filter},
  author    = {Wu, Huikai and Zheng, Shuai and Zhang, Junge and Huang, Kaiqi},
  booktitle = {CVPR},
  year = {2018}
}
Package: guided-interpolation
guided-interpolationA Python repository for 2D and 3D horizons-guided interpolationHere are some of the main features of guided-interpolation packageContinuous properties horizon-guided interpolation through inverse weighted distance and ordinary kriging.Discrete properties horizon-guided interpolation through indicator kriging.Sequential gaussian and indicator simulations horizon-guided.InstallationYou can install withpip:pip install guided_interpolationDocumentationComing soon!ContributingPlease seeCONTRIBUTING.md.
Package: guided-lambda-handler-tj
guided lambda handlerthis module houses shared code used to run lambda functions in a more focused mannerfirst time stuff:
pip install wheel
pip install twineuse python3 setup.py sdist bdist_wheel to make new version
then remove old whl and tar files
then usepython3 -m twine upload --repository testpypi dist/*to reuploadthen, in the project the library is to be used in, do
pip uninstall 
pip install --index-urlhttps://test.pypi.org/simple/--extra-index-urlhttps://pypi.org/simpleto get the latestonce the dependency is solidified, you don't have to use test.pypi, so instead, the above becomes:use python3 setup.py sdist bdist_wheel to make new version
then remove old whl and tar files
then usepython3 -m twine upload dist/*to reuploadthen, in the project the library is to be used in, do
pip uninstall 
pip install 
to get the latestDon't forget to save the dependency snapshot in this and the other package!
pip freeze > requirements.txt
Package: guietta
guiettaA tool for making simple Python GUIsGuietta is a tool that makes simple GUIssimple:fromguiettaimport_,Gui,Quitgui=Gui(["Enter numbers:","__a__","+","__b__",["Calculate"]],["Result: -->","result",_,_,_],[_,_,_,_,Quit])withgui.Calculate:gui.result=float(gui.a)+float(gui.b)gui.run()And here it is:Also featuring:matplotlib and pyqtgraph integration, for easy event-driven plotseasily display columns of data in labels using lists and dictsmultiple windowscustomizable behaviour in case of exceptionsqueue-like mode (a la PySimpleGUI)integrate any QT widget seamlessly, even your custom ones (as long as
it derives from QWidget, it is OK)easy background processing for long-running operationsordinary QT signals/slots, accepting any Python callable, if you really
want to use themInstallationpip install guiettaIf you use conda, please read our page onQT incompatibilities with conda.Install on older platformsGuietta uses thePySide2QT binding
by default, and some systems
(older Macs, Raspberry PI) do not have it available. Guietta can fallback
to the PyQt5 binding if available, but does not specify it as an automatic
dependency. If you get an
installation error about PySide2, try to use PyQt5 instead using the
following:pip install guietta --no-deps
    pip install pyqt5DocumentationStable version:https://guietta.readthedocs.io/en/stable/Latest update from github:https://guietta.readthedocs.io/en/latest/Tests
Package: gui-executor
# GUI ExecutorYou ever wanted to execute your Python code from a simple GUI without the need to use a REPL or commandline? Look no further, use GUI Executor.## InstallationInstall this package in your virtual environment:` $ python3-mpip install[--upgrade]gui-executor`## DocumentationYou can find the documentation athttps://ivs-kuleuven.github.io/gui-executor/.## Running the Tests` $PYTHONPATH=~/Documents/PyCharmProjects/gui-executor/testsgui-executor--module-pathtasks.shared--module-pathtasks.specific--debug`
Package: guify
GUIfySimplest form of GUI for automation scripts.Made with eel as python backend and react used as frontend.For Quick Start docs click hereMain tabConfig tabRunning the source codeSince we're using react, there's a custom scriptrun_debug.pyto run the eel backend so it does not conflict with the react dev server port.If you're working on the frontend usenpmrunstartThis will start react dev server and run python too in same terminal instance.If you're working on the python side, it is recommended to run the code in 2 seperate terminals:# In first terminalnpmrunstart:js# In second terminalnpmrunstart:guify# or "py ./run_debug.py"This is because unlike React, python won't restart eel session on change of the guify source, so you'd end up restarting python a lot.BuildingTo build the package (wheel and source) in dist folder, run the following:npm run build
Package: guildai
Guild AI is anopen sourcetoolkit that automates and optimizes machine learning experiments.Run unmodified training scripts, capturing each run result as a unique experimentAutomate trials using grid search, random search, and Bayesian optimizationCompare and analyze runs to understand and improve modelsBackup training related operations such as data preparation and testArchive runs to S3 or other remote systemsRun operations remotely on cloud acceleratorsPackage and distribute models for easy reproducibilityFor details, seeGuild AI website.Important links:Latest release on PyPIGuild AI websiteDocumentationOpen issues
Package: guilded.py
Welcome to guilded.py, a discord.py-esque asynchronous Python wrapper for Guilded's bot API. If you know discord.py, you know guilded.py.DocumentationDocumentation is available onRead the Docs.Basic Exampleimportguildedclient=guilded.Client()@client.eventasyncdefon_ready():print('Ready')@client.eventasyncdefon_message(message):ifmessage.author==client.user:returnifmessage.content=='ping':awaitmessage.channel.send('pong!')client.run('token')Bot exampleimportguildedfromguilded.extimportcommandsbot=commands.Bot(command_prefix='!')@bot.command()asyncdefping(ctx):awaitctx.send('pong!')bot.run('token')For more examples, see the examples directory in this repository.SupportJoin the guilded.py server for help & discussion. Use the #library-help channel.
Package: guilded-webhook
guilded-webhooka basic wrapper for guilded's webhooks(also works with discords, although this is due to both having very similar api's, any breaking changes on discord's side will not receive fixes)guilded support serverdiscord support serverBasic example:import guilded_webhook as guilded
import asyncio

async def main():
    hook = guilded.AsyncWebhook('https://media.guilded.gg/webhooks/REDACTED')
    await hook.send(content='test')

asyncio.run(main())orimport guilded_webhook as guilded

def main():
    hook = guilded.Webhook('https://media.guilded.gg/webhooks/REDACTED')
    hook.send(content='test')

main()guilded-webhook also supports embeds (heavily inspired by discord.py's embeds)import guilded_webhook as guilded
import asyncio
from datetime import datetime

async def main():
    hook = guilded.AsyncWebhook('https://media.guilded.gg/webhooks/REDACTED')
    embed = guilded.Embed(title="title", description="description", url="https://www.youtube.com/watch?v=dQw4w9WgXcQ", color=0x00ffff, timestamp=datetime.now())
    embed.add_field(title="field title", value="field value")
    embed.set_image("https://img.guildedcdn.com/ContentMedia/e67907d6efa7aebb0440097cb9a03672-Full.webp")
    await hook.send(content='test', embeds=embed)

asyncio.run(main())docsclass - AsyncWebHook(arg) str - url - webhook url.(kwarg) str - avatar - optional avatar override (image url).(kwarg) str - username - optional username override.(async) method - send(kwarg) string - content(kwarg) List[Embed] - embeds(kwarg) str - avatar - optional avatar override (overrides instance avatar) (image url).(kwarg) str - username - optional username override (overrides instance username)(kwarg) File - file to upload with the messageclass - WebHook(arg) str - url - webhook url.(kwarg) str - avatar - optional avatar override (image url).(kwarg) str - username - optional username override.method - send(kwarg) string - content(kwarg) List[Embed] - embeds(kwarg) str - avatar - optional avatar override (overrides instance avatar) (image url).(kwarg) str - username - optional username override (overrides instance username)(kwarg) File - file to upload with the messageclass - Embed(kwarg) str - title(kwarg) str - description(kwarg) str - url(kwarg) int - color (hex color)(kwarg) datetime.datetime - timestampmethod - add_field(kwarg) str - title(kwarg) str - value(kwarg) bool - inlinemethod - set_author(kwarg) str - name(kwarg) str - url(kwarg) str - icon_urlmethod - set_footer(kwarg) str - text(kwarg) str - icon_urlmethod - set_image(kwarg) str - url(kwarg) int - height(kwarg) int - widthmethod - set_thumbnail(kwarg) str - url(kwarg) int - height(kwarg) int - widthclass - File(arg) Union[str, bytes, os.PathLike, io.BufferedIOBase] - fp - filelike object to upload(arg) str - filename - filename to upload as (required when using BytesIO and similar)
Package: guildreader
JSON READER:JSON Data Management ModuleCommon Terms:key: file name to save/pull from (Stored as data_[key].json)CLS: Reader(directory, ids: list)create_file()Creates a KeyReturns: Success(T/F)ex.reader.create_file("mutes", {}))key: File/Key to makedefault: Default value stored for each idwipe: Wipes the file if it existsread_file()Read a Key from a IDReturns: JSON for that IDex.data = reader.read_file(id, "mutes")
data[USER] = int(time.time+300)id: ID to readkey: File/Key to readwrite_file()Write to a keyReturns: Success(T/F)ex.reader.write_file(id, "mutes", data)ID: ID to write tokey: File/Key to write tovalue: Modified Valueremove()Remove a id from a keyReturns: Success(T/F)ex.reader.remove(id, "mutes")id: ID to removekey: File/Key to remove id fromcheck_exist()Checks if a Key existsReturns: Success(T/F)reader.check_exists("mutes")key: Check the existance of a key/filedump()Dumps the entire JSONReturns: JSON of the Keyjson = reader.dump("mutes")key: Key to dump json from
Package: guildwars2api
A Python Wrapper for the Guild Wars 2 APIFree software: BSD licenseDocumentation:https://guildwars2api.readthedocs.org.InstallationThis package is hosted on PyPI so it can be install using pip or easy_install:$ easy_install guildwars2api
$ pip install guildwars2apiFeaturesProvides an API wrapper for the current Guild Wars 2 API Resources.Works with Python 2.6, 2.7, 3.3, 3.4.History0.7.1 (2016-02-07)Fixed an import bug with the GuildWars2ApiErrorRemoved a test case for pagination. Will refactor the test with mock on the API calls.0.7.0 (2016-02-07)Refactored how URLs are constructed in the BaseResource classAdded the following resourcesGuild UpgradeGuild PermissionGuild MemberGuild Rank0.6.0 (2015-12-13)Added the following resourcesWvW ObjectivesMinisAccount MinisAchievementsAccount Achievements0.5.0 (2015-09-08)Added the following resourcesPvP StatsPvP GamesSpecializations0.4.0 (2015-08-30)Added the following resourcesCurrencyAccount WalletAccount Dye UnlocksAccount Skin Unlocks0.3.0 (2015-07-06)Added the following resourcesMaterialsBankBank MaterialsCharactersInventoryEquipmentAccountToken Info0.2.0 (2015-05-21)Added get_all() method to resources that use paging to return an iterator over all of the requested resourcesAdded the ability to pass an iterable as an argument and have it automatically expand into a comma-separated listAdded the ability to authenticate use an API keyAdded a new resource for Commerce Transactions0.1.0 (2015-04-12)First release on PyPI.
Package: guildwatcher
GuildWatcherA discord webhook that posts guild changes (member joins, members leaves, member promoted) in a Discord channel.Installingwith pipTo install the latest version on PyPi:pipinstallguildwatcherorInstall the latest version from GitHubpipinstallgit+https://github.com/Galarzaa90/GuildWatcher.gitwith dockerdockerpullgalarzaa90/guild-watcherwith gitYou can download the files and run locally, but you will require to install dependencies yourself:gitclonehttps://github.com/Galarzaa90/GuildWatcher
pipinstall-rrequirements.txtConfiguring WebhooksOn the desired channel, go to its settings and click on theWebhookssection.Click onCreate Webhook.Customize the avatar as needed.Copy the webhook's URL.Create a file namedconfig.ymland edit it, basing it onconfig-example.yml.The top levelwebhook_urlwill be used, but if you want another guild to use a different URL, you can specify one for that guild.RunningThe data directoryThe script saves every guild's data to a.datafile. On the next scan, the current state of the guild is compared with the previous guild's data in order to detect the changes.The.datafiles allow the script to be able to keep track of changes between executions. Without a.datafile, if the script was stopped and was executed an hour later, all changes that occurred in that time frame would not be detected.Installed via pip or locallyconfig.ymlmust be in the same directory you're running the script from.If installed using pip, you can run the script in one of two ways:guildwatcherorpython-mguildwatcherFrom docker imageIn order to run the script from a docker image, you need to mount the configuration file to/app/config.yml.While not required, it is highly recommended mounting a directory to store the guild data, to persist data files between executions. The data folder must be mounted to/app/data/.dockerrun\-v"$(pwd)"/config.yml:/app/config.yml\-v"$(pwd)"/data/:/app/data/\--rm-itgalarzaa90/guild-watcherCurrent FeaturesAnnounces when a member joins.Announces when a member leaves or is kicked.Announce when a member is promoted or demoted.Announce when a member changes name.Announce when a member's title is changed.Announce when a new character is invited.Announce when an invitation is revoked or rejected.Announce when the guildhall changes.Announce when a guild's application status is changedAnnounce when a guild is in risk of being disbanded.Multiple guilds support.Configurable scan times.Webhook URL configurable per guild.Known IssuesRenaming a rank would trigger all rank members getting announced as leaving and joining back.Planned featuresAnnounce changes in guild attributes.Application statusDisband warningGranular notification settings (e.g. disable rank changes, disable title changes, etc.)Example