Saravanan666/pypi-org huggingface dataset:
Package: gazetimation
GazetimationAn out of the box solution for gaze estimation.Installationpip install gazetimationUsagefromgazetimationimportGazetimationgz=Gazetimation(device=0)# or any other device idgz.run()To run a video filegz.run(video_path='path/to/video')To save as a video filegz.run(video_output_path='path/to/video.avi')Therunmethod also accepts a handler function for further processing.gz.run(handler=my_handler)AttentionThe handler function will be called by passing the frame and the gaze informationifhandlerisnotNone:handler([frame,left_pupil,right_pupil,gaze_left_eye,gaze_right_eye])For more info check ourdocsIssuesIf any issues are found, they can be reportedhere.LicenseThis project is licensed under theMITlicense.AcknowledgementThis package was inspired from the amazingMedium
postby Amit Aflalo
Package: gazi
gaziA lightweight, class-based, easy-to-use ASGI frameworkDocsmain.pyfromgaziimportAppfromhomeimport_asHomefromapiimportAPIapp=App()app.handlers([Home,API])home.pyfromgazi.routeimportmethodfromgazi.responseimportHtmlResponse,Response# Path: /*class_:def__init__(self)->None:pass# Path: /@method.GETdef__render__(self)->Response:returnHtmlResponse("<h1>Hello, world!</h1>")api.pyfromgazi.responseimportHtmlResponse,Responsefromgazi.requestimportRequestfromgazi.routeimportmethod# Path: /api/*classAPI:def__init__(self)->None:pass# Path: /api@method.GETdef__render__(self)->Response:returnResponse("API")# Path: /api/hello@method.GETdefhello(self,request:Request)->Response:returnHtmlResponse(f"<h1>Hello world, Username:{request.query('name')}</h1>",# data{"test1":"test","asd":"a"},# headers)# Path: /api/bye?name=test@method.POSTdefbye(self,request:Request)->Response:returnHtmlResponse(f"<h1>Bye world, Username:{request.query('name')}</h1>")
Package: gazoo
GazooWrap Minecraft Bedrock server to make proper backups.RationaleInstallationConfigurationUsageSimilar projectsRationaleThe Minecraft Bedrock server expects input from STDIN in order to perfrom
backups properly.  Since no other form of IPC exists, a wrapper is used to
automate sending the save commands to the Bedrock server's STDIN.  The wrapper
also forwards all STDIO transparently, so the wrapper acts as a drop-in
replacement.InstallationGazoo ispublishedto thePython Package Index (PyPI)and can be installed withpip.pipinstallgazooConfigurationGazoo writes all its files to agazoosubdirectory in the current working
directory.  Runninggazoofor the first time will create agazoo.cfgfile in
thegazoosubdirectory, among other setup.  The configuration file is a simpleINI-stylefile with only a few options:backup_intervalTime between backups (in seconds)Default value:600(10 minutes)cleanup_intervalTime between cleanups (in seconds)Default value:86400(24 hours)debugWhether to output debug informationDefault value:falseUsagePlease note:gazoorequires being run in the context of the Bedrock server
root directory.  This means you will need tocdto the Bedrock server root
directory before callinggazoo, or setPWD, or something else appropriate
for your situation.By default (without any additional arguments),gazoowraps the Bedrock server
transparently (with all STDIO forwarded).  Saving and cleanup is performed
automatically as configured in thegazoo.cfgfile.For convenience, two commands are also provided:cleanup, andrestore.Thecleanupcommand simply runs the cleanup portion of the program and then
exits.  This is useful if there are backups that need to be cleaned up, but you
don't want to start the Bedrock server.Therestorecommand restores saves made by gazoo.  If used without any
additional arguments,restorerestores the most recent save.  An integer
argument can be provided to restore the nth most recent save.  E.g. passing1restores the first most recent save (and is equivalent to passing nothing),
passing2restores the second most recent save, etc.  Alternatively, a file
path to a backup can be specified.Similar projectsgithub.com/debkbanerji/minecraft-bedrock-servermay provide some similar functionality (untested/unvetted).
Package: gazpacho
Aboutgazpacho is a simple, fast, and modern web scraping library. The library is stable, actively maintained, and installed withzerodependencies.InstallInstall withpipat the command line:pip install -U gazpachoQuickstartGive this a try:fromgazpachoimportget,Soupurl='https://scrape.world/books'html=get(url)soup=Soup(html)books=soup.find('div',{'class':'book-'},partial=True)defparse(book):name=book.find('h4').textprice=float(book.find('p').text[1:].split(' ')[0])returnname,price[parse(book)forbookinbooks]TutorialImportImport gazpacho following the convention:fromgazpachoimportget,SoupgetUse thegetfunction to download raw HTML:url='https://scrape.world/soup'html=get(url)print(html[:50])# '<!DOCTYPE html>\n<html lang="en">\n  <head>\n    <met'Adjustgetrequests with optional params and headers:get(url='https://httpbin.org/anything',params={'foo':'bar','bar':'baz'},headers={'User-Agent':'gazpacho'})SoupUse theSoupwrapper on raw html to enable parsing:soup=Soup(html)Soup objects can alternatively be initialized with the.getclassmethod:soup=Soup.get(url).findUse the.findmethod to target and extract HTML tags:h1=soup.find('h1')print(h1)# <h1 id="firstHeading" class="firstHeading" lang="en">Soup</h1>attrs=Use theattrsargument to isolate tags that contain specific HTML element attributes:soup.find('div',attrs={'class':'section-'})partial=Element attributes are partially matched by default. Turn this off by settingpartialtoFalse:soup.find('div',{'class':'soup'},partial=False)mode=Override the mode argument {'auto', 'first', 'all'} to guarantee return behaviour:print(soup.find('span',mode='first'))# <span class="navbar-toggler-icon"></span>len(soup.find('span',mode='all'))# 8dir()Soupobjects havehtml,tag,attrs, andtextattributes:dir(h1)# ['attrs', 'find', 'get', 'html', 'strip', 'tag', 'text']Use them accordingly:print(h1.html)# '<h1 id="firstHeading" class="firstHeading" lang="en">Soup</h1>'print(h1.tag)# h1print(h1.attrs)# {'id': 'firstHeading', 'class': 'firstHeading', 'lang': 'en'}print(h1.text)# SoupSupportIf you use gazpacho, consider adding thebadge to your project README.md:[![scraper: gazpacho](https://img.shields.io/badge/scraper-gazpacho-C6422C)](https://github.com/maxhumber/gazpacho)ContributeFor feature requests or bug reports, please useGithub IssuesFor PRs, please read theCONTRIBUTING.mddocument
Package: gazta
You are two steps away from winning a handmade cheese!Install this package and see what happens.Just for EuroPython 2016 attendantsCodeSyntax, 2016History0.2.1 (2016-07-15)Fix README0.2 (2016-07-15)Fix single-version-externally-managed problem0.1.0 (2016-07-13)First release on PyPI.
Package: gazu
Gazu, Python client for the Kitsu APIThe Kitsu Python client allows you to fetch data easily from the Kitsu
collaboration platform. With Gazu, you bring assets and shots data into your
pipeline tools. It comes with extra features such as preview publishing and
event stream listening.It is made to be used with theKitsu API. It
requires an up-and-running instance of Kitsu to run correctly.QuickstartInstall Gazu in your application environment via pip:pipinstallgazuThe client requires a few extra configurations before being used. It
needs to know where is located the API server and to log in:importgazugazu.set_host("https://zou-server-url/api")gazu.log_in("user@yourdomain.com","password")Let’s finish with an example. Fetch all the open projects:projects = gazu.project.all_open_projects()DocumentationDocumentation and specification are available on a dedicated website:https://gazu.cg-wire.comProjects using the Kitsu clientOur community-built open-source tools connect your content creation tools to
your Kitsu instance. They are listed below:Qtazu: Qt Widgets such as a login
modal.Nagato: Publishing and file versioning
for Blender.Bamboo: Pyside2 widgets to publish
previews to Kitsu.Gazu Publisher: Our work in
progress publisher tool.ContributionsAll contributions are welcome as long as they respect theC4
contract.The code must follow the pep8 convention.You can use the pre-commit hook for Black (a Python code formatter) before committing :pipinstallpre-commitpre-commitinstallContributors@aboellinger (Xilam)@BigRoy (Colorbleed)@col-one (Allegorithmic)@EvanBldy (CGWire) -maintainer@flablog (Les Fées Spéciales)@frankrousseau (CGWire) -maintainer@kguyaux@LedruRollin (Xilam)@g-Lul (TNZPV)@jdrese (HEAJ)@pcharmoille (Unit Image)@tokejepsen (Bumpybox)@tpodevaAbout authorsKitsu is written by CGWire, a company based in France. We help animation and VFX studios to collaborate better through efficient tooling. We already work with more than 70 studios around the world.Visitcg-wire.comfor more information.
Package: gazze
gazzeA Python Web Framework for High-Performance APIsSummaryGazze is an exciting Python web framework, developed on top of the powerful Starlette and the amazing FastAPI. The primary goal of Gazze is to provide an exceptional experience in developing highly performant APIs in Python.Important Notices:Please be aware that Gazze is an ongoing development and research project. Currently, it is not recommended for use in production environments. We are working diligently to improve and mature the framework, but it is still in its early development stage.Installation$ pip install gazzeYou will also need a ASGI Server like Uvicorn or Hypercorn$ pip install "uvicorn[standard]"Examplefromgazze.responsesimportJSONResponsefromgazze.applicationsimportGazzeapp=Gazze(debug=True,)@app.get("/items/{item_id}")asyncdefread_item(request):item_id=request.path_params.get('item_id')returnJSONResponse({"item_id":item_id})Run$ uvicorn main:app

INFO:     Started server process [51753]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)Key Features:Built on top of Starlette and FastAPI.Focused on creating high-performance APIs.Modern and developer-friendly design.Open-source licensing for flexibility and collaboration.Contributions:We look forward to collaborations and contributions from the community to help Gazze evolve and grow. Your input is highly appreciated in shaping the future of this project.
Package: gb
gbAboutgbor gopherball is a gopher library written in Python with the main goals of
ease of use and integration. The name gopherball is inspired by a recurring
theme in the Calvin & Hobbes comicbooks and a tongue in cheek reference of an
alternative to the World Wide Web as we know it today.ExamplesThere are several other projects that are built on top ofgbto get you running:ServerCheck out thegbsproject.ClientCheck out thegbcproject.ProxyCheck out thegbxproject.Technologygbis written with the help of Python 3.9 and higher and the Tornado
framework for its networking.ContributingThe source code forgblives on my GitHub where you can also submit issues
and pull requests. It mostly needs help by people with the ability to test in
various clients and libraries that might still support the gopher protocol.
Package: gback
This package provides an simpler interface to Google calendars using
the google-api-python-client python package and OAuth.ExamplesNote: See the “Setting up the project on Google” section below before trying
the examples.List calendar names:>>> from gback import GCalSession
>>> session = GCalSession('~/gback.oauth')
>>>
>>> for c in session.names: print cAdd an appointment to a named calendar:>>> from gback import GCalSession

>>> # print the output will display the appiointment url.
>>> # 'Marc' is the name of the calendar used.

>>> session = GCalSession('~/gback.oauth')
>>> des='Write a simpler way to use the google calendar api.'
>>> print session['Marc'].add('Write Python code.', '20150430', des=des)Create an ical file for all the appointments in the named calendar:>>> from gback import GCalSession

>>> cal_name = 'Marc'
>>> session = GCalSession('~/gback.oauth')
>>> with open(cal_name + '.ical'), 'w') as fh:
>>>   fh.write(session[cal_name].events)Setting up the project on GoogleVisit:https://console.developers.google.com/project/Choose “Create Project”
Enter a project name.  This can be anything.
I used “gback” for google backup.
Read the agreements and agree to them if you wish to continue.
Wait while Activities windows works on setting up your project.
Select “APIs & auth” on the left pane to expand menu items.
select “Credentials”
select “Create new Client ID”
select “Installed application”Answer consent screen information prompt.Select your email address and enter your project name in the “Product
Name” field.  I entered “gback”.Click on “Save”If prompted to create another client id.  Click on “Cancel”.You have to repeat the following steps.  But this time “gback” should be
shown in the drop down box at the top of the web page.select “Create new Client ID”
select “Installed application”
select “Other” for the installed application type.Now  you should have a “Client ID for native application shown”.
Select “Download JSON”That will save a JSON file with a client_id and client_secret among
other things.  It will have a long file name but you can rename it to
anything you like, “gback.json”, say.Enable APIs:Under “APIs & auth” select “APIs”
Select “Google+ API”
Then enable it.Under “APIs & auth” select “APIs”
Select “Calendar API”
Then enable it.The first time you run this program it will launch your browser to log
into your Google account.  It will get a key and save it to your named
OAuth file using the –oauthfn arg.  After that it will read your OAuth
file to get the key.$ python gback.py -l –clientfn gback.json –oauthfn gback.oauthAfter logging in using on your browser click on ‘Accept’ when prompted that
gcalcback would ike to “Manage your calendars”.From now on the gback.py program should work using the gback.json and
gback.oauth files without need for a browser.Note:Running this program requested permission which needed validation
using a browser which did not work with w3m because it doesn’t support
Javascript.  I had to run it the first time on ny in xwindows so it
could launch chrome for validation.  It stored keys etc using
Storage() to a file so that it doesn’t need to revalidate again.
Package: gbackup
gbackup==========A utility to backup all [Gitlab](https://gitlab.com) projects of a user orgroup. It can download projects of multiple groups and users.# RequirementsThis requires `python-gitlab` package and requires Python 3.5+.# SetupThese setup requirements will setup a python[virtualenv](https://virtualenv.pypa.io/en/latest/) to run the script whichbacks up all your projects.First, setup a config file with your access credentials. `user` and `group` areoptional, you can specify whichever one you want to backup.```# ~/.gbackup.ini[main]server = https://gitlab.comtoken = <access-token>group =<gitlab-group1><gitlab-group2><gitlab-group3>user =<gitlab-username>backup_dir = ~/.gitlab-backup```Now, let's setup [virtualenv]((https://virtualenv.pypa.io/en/latest/)) and startbackup.```bash$ git clone https://github.com/maxking/gbackup$ cd glbackup$ python3 -m venv gitlab$ source gitlab/bin/activate(gitlab)$ pip install python-gitlab```# UsageFinally, to start the backup, run the `gbackup.py` script.```$ ./gbackup.pyDownloading backup for https://gitlab.com/maxking/mailman to /home/maxking/.gitlab-backup/maxking/mailman/11-Jan-2019-19-53.tar.gz```# LicenseAll the contents of this repository is licensed under Apache Licensev2.0. Please see the LICENSE file for complete license text.
Package: gbapi
gbapiqeaml's wrapper for GameBanana's APIAboutgbapiis a straight-to-the-point, asynchronous Python API wrapper forGameBanana's API. Please do note that this is my first
proper API, so go easy on me :) If you want to get in contact with me through
GB,click hereto go to my profile, and feel free to PM me about anything.RequirementsPython 3.6+aiohttpGetting startedFirst, install the library withpip:pip install gbapiThen, simply import it and use theClientto communicate with GameBanana!importgbapigb=gbapi.Client()awaitgb.get_map(123)awaitgb.get_skin(456)awaitgb.(...)Here's a basic example:importasyncioimportgbapiasyncdefmain():gb=gbapi.Client()m=awaitgb.get_map(12345)print(m.game.name)#prints the name of the game the map is forprint(m.author.name)#prints the name of the submitterawaitgb.close()#remember to always close() your client !if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(main())
Package: gbasis
AboutLicenseGBasis is distributed under GPL License version 3 (GPLv3).DependenciesThe following dependencies will be necessary for GBasis to build properly,Python >= 2.7, >= 3.5:http://www.python.org/SciPy >= 0.11.0:http://www.scipy.org/NumPy >= 1.9.1:http://www.numpy.org/Nosetests >= 1.1.2:http://readthedocs.org/docs/nose/en/latest/InstallationTo install GBasis:`bash./tools/libs/install_libint-2.0.3.shpython ./setup install--user`TestingTo run tests:`bash nosetests-vgbasis `
Package: g-batch-prediction-pipeline
Batch Prediction PipelineCheck out thisMedium articlefor more details about this module.Create Environment File~/energy-forecasting$cp.env.default.envThe commandcp .env.default .envis used to create a copy of the.env.defaultfile and name it.env. In many projects, the.envfile is
used to store environment variables that the application needs to run. The.env.defaultfile is usually a template that includes all the environment
variables that the application expects, but with default values. By copying it
to.env, you can customize these values for your own environment.Set Up the ML_PIPELINE_ROOT_DIR Variable~/energy-forecasting$exportML_PIPELINE_ROOT_DIR=$(pwd)The commandexport ML_PIPELINE_ROOT_DIR=$(pwd)is setting the value of theML_PIPELINE_ROOT_DIRenvironment variable to the current directory. In this
context,$(pwd)is a command substitution that gets replaced with the output
of thepwdcommand, which prints the path of the current directory. Theexportcommand then makes this variable available to child processes of the
current shell.In essence,ML_PIPELINE_ROOT_DIRis an environment variable that is set to the
path of the current directory. This can be useful for scripts or programs that
need to reference the root directory of the ML pipeline, as they can simply
refer toML_PIPELINE_ROOT_DIRinstead of needing to know the exact path.Install for DevelopmentThe batch prediction pipeline uses the training pipeline module as a dependency.
Thus, as a first step, we must ensure that the training pipeline module is
published to our private PyPi server.NOTE:Make sure that your private PyPi server is running. Check theUsage sectionif it isn't.Build & publish thetraining-pipelineto your private PyPi server:cdtraining-pipeline
poetrybuild
poetrypublish-rmy-pypicd..Install the virtual environment forbatch-prediction-pipeline:~/energy-forecasting$cdbatch-prediction-pipeline&&rmpoetry.lock
~/energy-forecasting/batch-prediction-pipeline$bash../scripts/devops/virtual_environment/poetry_install.sh
~/energy-forecasting/batch-prediction-pipeline$source.venv/bin/activateCheck theSet Up Additional ToolsandUsagesections to
seehow to set uptheadditional toolsandcredentialsyou need to
run this project.Usage for DevelopmentTo start batch prediction script, run:~/energy-forecasting/batch-prediction-pipeline$python-mbatch_prediction_pipeline.batchTo compute the monitoring metrics based, run the following:~/energy-forecasting/batch-prediction-pipeline$python-mbatch_prediction_pipeline.monitoringNOTE:Be careful to set theML_PIPELINE_ROOT_DIRvariable as explained in
thissection.
Package: gb-automation-client
GBA getting startedPlease note this will only work with GBA version v1.5.0 or greater.pip install gb-automation-clientCreate a clientimportgbaclient_factory=gba.ClientFactory()client=client_factory.create()You can optionally pass a dictionary when creating the clientconfig={baseUrl:'',}client=client_factory.create(config)Alternatively, use env vars for configurationGBA_BASE_URL=List devicesclient.list_devices()
Package: gbayes
gbayesGBayes: a minimalistic Computational Framework for Generalized Bayesian Inference.Installation$pipinstallgbayesUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensegbayeswas created by Tomas A Olego. It is licensed under the terms of the MIT license.Creditsgbayeswas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: gbbox
📐 geojson-bboxSimple Python module for calculating bounding box (bbox) from given GeoJSON object.Currently following GeoJSON objects are supported (RFC 7946):PointMultiPointLineStringMultiLineStringPolygonMultiPolygonGeometryCollectionInstallation$pipinstallgbboxUsage>>>fromgbboximportLineString>>>>>>linestring_geojson={>>>"type":"LineString",>>>"coordinates":[>>>[1.0,2.0],>>>[3.0,4.0]>>>]>>>}>>>>>>linestring=LineString(**linestring_geojson)>>>linestring_bbox=linestring.bbox()>>>print(linestring_bbox)>>>[1.0,2.0,3.0,4.0]>>>print(linestring.min_lon)>>>1.0Development$dockercomposeup-d# Start bash within container and enter it$dockerexec-itgbboxbashProject will be automatically installed within docker container in an editable mode and
any code changes will be immediately reflected. Keep in mind that if you have python shell
running then you have to restart it.You can also usemake lintandmake testas shortcuts to run linters and tests.ContributingI am open to, and grateful for, any contributions made by the community.
Package: gbcg3
gbcg3: Graph-Based Coarse Graining in Python 3gbcg3 is a Python package that automates the creation of coarse-grained models for molecular simulations from all-atom models. This package reimplementsGraph-based coarse graining methodin Python 3, providing an efficient tool for the modern computational chemistry community.FeaturesAutomated Generation of Coarse-grained Models: gbcg3 can generate coarse-grained models for molecular simulations from full atomistic models, streamlining the process and reducing the amount of manual work required.Graph-based Coarse Graining: This package utilizes the Graph-based coarse graining method, offering a powerful technique to simplify molecular systems while preserving their essential features.Compatibility with LAMMPS: You can use the LAMMPS trajectory and data files as inputs for this package. We plan to extend the range of compatible formats in future updates.InstallationTo install gbcg3, use pip:pipinstallgbcg3UsageAfter you have installed the package, you can use it as follows:fromgbcg3importAA2CG# Create a CoarseGrain object with your LAMMPS data fileaa2cg=AA2CG(traj=["atom.lammpstrj"],data="sys.data",niter=5,min_level=[2,2,2,3,4],max_level=[2,3,3,3,4],output_dir="output",log_filename=None,names="lmps2type.map",)# Perform coarse grainingaa2cg.run()This will create a coarse-grained model from your LAMMPS data file. Some examples are inexample.ContributingWe welcome any contributions! If you have suggestions for additional features, find bugs, or want to improve the package in any other way, feel free to open an issue or a pull request.LicenseThis project is licensed under the GNU General Public License v3.0. See theLICENSEfile for details.