Saravanan666/pypi-org huggingface dataset:
Package: gsql-client
gsql_clientIntroductionIf you are using TigerGraph, you probably know that there are only one way to remotely execute
your GSQL scripts: gql_client.jar. This jar is an interactive console and you can not programmatically
access GSQL server (until 2.4 TigerGraph introduces JDBC based access). But we love Python,
right?So here we are: a Python version of gsql_client, removing all interactive features. gsql_client.jar
actually uses http to interact with GSQL server. So can Python. TigerGraph already open sourced theirclient implementation, but only
for versions later than 2.3.0. I originally wrote this for 2.2.3, so there are minor differences.InstallationCopy gsql_client folder to your project or install with pip:pipinstallgsql_clientThis package has no external dependency and it is compatible with both Python 2 and 3.Note:if you submit large gsql files or long running commands, using remote client may receive
IncompleteRead exception as TigerGraph nginx service does not properly configure theproxy_read_timeoutfor/gsqlserverpath. So you may need to edit{TIGERGRAPH_HOME}/tigergraph/config/nginx/nginx_1.confand add this option (like for/admin/websocketor/websocket).TODOMaybe I could create a main function to launch an interactive shell (using stdlib cmd module), so that
we can usepython -m gsql_clientjust asjava -jar gsql_client.jar. It is best to keep them compatible
(for both command line options and behaviors).UsageIt contains mainly 2 classes: gsql_client.Client as a remote GSQL server client and
gsql_client.RESTPP for directly interact with RESTPP server.fromgsql_clientimportClient,RESTPP# default port 14240, you can use 10.0.0.1:29383 to specify another portclient=Client("10.0.0.1")# for versions later than 2.4.0, it is mandatory to specify the version like this:client=Client("10.0.0.1",version="v2_4_0")# or the login would fail with incompatible server/client version# you can directly specify the commit hash of the client (used for compatibility check) by:client=Client("10.0.0.1",version="v2_6_0",commit="somehexhashstring")client.login()# returns True for success; exceptions and False for failureres=client.command("ls")# also returns the result as a list of linesclient.command("clear graph store","y")# needs answerclient.run_file("yourfile.gsql")client.version()client.help()client.quit()restpp=RESTPP("10.0.0.1")# default port 9000# no need to login# but you can use restpp.requesttoken(secret) to setup token based authentication:secret=client.get_secret("my_graph",create_alias="my_graph_query_secret")# use=True for directly using the requested tokentoken=restpp.request_token(secret,use=True)# or with set_tokenrestpp.set_token(token)# same as type `select * from MyVertex` in gsql shellrestpp.select_vertices("my_graph","MyVertex")restpp.query("my_graph","my_query",param1=1)# run your query
Package: gsqlite3
A gevent-ification of pysqlite3, including a SQLAlchemy dialect.The module takes a simple approach of any potentiall long running methods off
to the gevent hub threadpool for execution.This lets greenlet code perform parallel queries.Try thedemoscript.$pythondemo.pyPopulating'demo.sqlite'...gsqlite3:10loops,bestof3:105msecperloopsqlite3:10loops,bestof3:243msecperloopSQLAlchemyYou can use gsqlite3 with SQLAlchemy by specifying ‘sqlite+gsqlite3’ as your URL scheme.
Package: gs-quant
GS QuantGS Quantis a Python toolkit for quantitative finance, created on top of one of the world’s most powerful risk transfer platforms. Designed to accelerate development of quantitative trading strategies and risk management solutions, crafted over 25 years of experience navigating global markets.It is created and maintained by quantitative developers (quants) at Goldman Sachs to enable the development of trading strategies and analysis of derivative products. GS Quant can be used to facilitate derivative structuring, trading, and risk management, or as a set of statistical packages for data analytics applications.Please refer toGoldman Sachs Developerfor additional information.RequirementsPython 3.6 or greaterAccess to PIP package managerInstallationpip install gs-quantExamplesYou can find examples, guides and tutorials in the respective folders as well as onGoldman Sachs Developer.ContributionsContributions are encouraged! Please seeCONTRIBUTINGfor more details.HelpPlease reach out togs-quant@gs.comwith any questions, comments or feedback.
Package: gsquickstart
gsquickstart is a TurboGears quickstart template plug-in for Genshi templates.It will install a paste template which can be used with TurboGears'``tg-admin quickstart`` command.Installation------------Installation with setuptools::$easy_install gsquickstartUsage-----Creating a project~~~~~~~~~~~~~~~~~~The gsquickstart template is used like any other quickstart template withtg-admin quickstart, you just have to specify the template name, which is"tggenshi" (for TurboGears Genshi) with the ``-t`` option  template insteadof the default kid template::$tg-admin quickstart -t tggenshi [project name]This will install three basic Genshi tempaltes and set up the projectconfiguration to use Gensi templates as default.Updating a project~~~~~~~~~~~~~~~~~~For updating a project with the basic Genshi templates, change into yourproject directory and run::tg-admin update -t tggenshiSince the "turbogears" template already installs Kid templates in``<package>/templates``, they are removed by gsquickstart in apost-template-creation step. But when update your project dir, the Kidtemplates will be created again. Now gsquickstart can not just delete themagain, because they might have been created earlier and on purpose by thedeveloper.What the new code does is: if it is an update command, prompt the user,if the files ``<package>/templates/{login,master,welcome}.kid`` shouldbe removed (for each file). The default answer is 'n'.Notice------The TurboGears 1.0 documentation is written with the default setting ofKid & SQLObject in mind. The syntax of Genshi templates is very similarto that of Kid but there are some differences to bear in mind.For example, you need to make some changes to your templates, if you usewidgets with Genshi templates: put ``${ET(myform())}`` instead of``${myform()}`` as a placeholder for widgets in the template.You can find more information in the `TurboGears documentation`_ and onthe `Genshi website`_... _TurboGears documentation :http://docs.turbogears.org/1.0/GenshiTemplating.. _Genshi website: http://genshi.edgewall.org/wiki/GenshiFaqWhat's new?-----------1.0---* The quickstart template was stripped of almost all files shared with thestandard "turbogears" template and now inherits from this template insteadof from "tgbase". The only files that are added/overwritten by "tggenshi"are ``setup.py``, ``<package>/config/app.cfg`` and the Genshi templatesin ``<package>/templates/*.html``. But see the "Updating a project" sectionabove.The new template structure makes it easier to stay synchronized with changesto the standard turbogears template since most files will just beinherited from.* Synchronized ``app.cfg_tmpl` and `setup.py_tmpl`` with the latest"turbogears" template.1.0Beta2--------* Able to be indexed by turbogears cogbin.
Package: gs-reminder
gs-reminderNotify Slack of a review of Pull Requests in the GitHub repository.EnvironmentsPython 3.8 or laterpoetryUsagepipinstallgs-reminder
gs-reminder-rnnsnodnb/gs-reminder-uexamples/username.json--iconEnvironment variablesGITHUB_TOKENRequiredYour GitHub Personal Access Token.Createhttps://github.com/settings/tokensSLACK_URLRequiredIncoming webhook's url of Slack app.Options--repoor-rRequiredYour GitHub repository name. (ex.nnsnodnb/gs-reminder)--file-usernameor-uOptionalCorresponding files for GitHub and Slack usernames. (ex.examples/username.json)[{"github":"nnsnodnb","slack":"yuya.oka"}]--limitor-lOptionalNumber of Pull Requests to notify Slack. Max: 20 (default: 20)--iconor-iOptionalGive GitHub icons to Slack notifications.--exclude-usersor-euOptionalGitHub users to remove from reviewers upon notification.-eu nnsnodnb # this name is GitHub usernameExample ResultLicenseThis software is licensed under the MIT License.
Package: gs_reply_bot
Installationpip install gs_reply_botorpython3 setup.py installBasic usageSet the configuration parameters in the default location ($XDG_CONFIG_HOME/gs_reply_bot/config.json) or supply it to the script with-c.Configuration example:{
    "server_url": "https://gnusocial.server",
    "username": "username",
    "password": "password",
    "users": {
        "user@gnusocial.server": ["message", "another message"]
    }
}
Package: gsrest
gsrestGeoServer python REST API client.AboutThis package is on an early stage, but may be functional for your needs.At this point, the only documentation is the one on source files and the tests
themself.FeaturesHTTP only.Warning: your geoserver credentials may be publicly exposed.Python >= 3.7.Static setup of the connection for all GeoServer elements.Easily extendable.CLI to upload from YAML (great for automation).Just PyYAML as runtime dependency.InstallationDownload fromPyPI:pip install gsrestSample usageTo test the client, you need a geoserver instance. For simplicity, in this
example we will use thegeoserver docker image from
kartoza:$ docker run -d --rm -p 8080:8080 --name geoserver kartoza/geoserver:2.17.0Let's setup the client credentials. Default values work fine with the docker
instance.$ python
>>> from gsrest import client
>>> client.GsClient()  # will setup the connection for all elementsNext, let's create a local workspace and sync (upload) it to the server.>>> from gsrest.elements import workspace
>>> wsp = workspace.WorkSpace("wsp1")
>>> wsp.uri = "http://my.uri/"
>>> wsp.sync()Then, you can check the new workspace athttp://localhost:8080/geoserver(useradmin/ passwordgeoserver).Finally, do not forget to kill the docker instance.$ docker kill geoserverLicenseLicensed under the term ofGPL-3.0-or-later LICENSE. SeeLICENSE.
Package: gssapi_console
[![PyPI version](https://badge.fury.io/py/gssapi_console.svg)](https://badge.fury.io/py/gssapi_console)
[![GitHub version](https://badge.fury.io/gh/pythongssapi%2Fgssapi-console.svg)](https://badge.fury.io/gh/pythongssapi%2Fgssapi-console)GSSAPI Consoleallows provides an easy way to test out Python applications
using GSSAPI in a self-contained environment.By default, the console will set up a self-contained MIT krb5 environment.
However, other GSSAPI environments are planned.Requirements[python-gssapi](https://pypi.python.org/pypi/gssapi) >= 1.1.0Requirements for the environment used (for example, the default environment is
MIT krb5, which uses the [k5test](https://pypi.python.org/pypi/k5test))Usagefurther information is available by running `gssapi-console.py –help`The main executable of GSSAPI Console isgssapi-console.py.  The basic
invocation works just like launchingpython– usegssapi-console.py FILEto run a file in the established environment, or just rungssapi-console.pyorgssapi-console.py -ito get an interactive environment (the-iflag
can be used with a file, just likepython FILE -i).There are several additional flags that may be passed togssapi-console.py:–realm-args key1=true,key2=false,…can be used to pass specific arguments
to the realm constructor (the set of such keys is driver-dependent)–mech MECH_NAMEcan be used to specify a different driver (currently, only–mech krb5will work)-a IDENTIFIER, –attach IDENTIFIERmay be used to “attach” a new GSSAPI Console
session to an environment set up by an existing GSSAPI Console session.  The identifier
will be noted at the top of the existing GSSAPI Console session asSession: IDENTIFIER.-v, –verbosemay be used to increase the verbosity of the logging level (generally to
gain more details on what the driver is doing to set up the realm).Additional GSSAPI Console drivers may be introduced using thegssapi_console.driverssetuptools entry point.  They should follow thegssapi_console.drivers.GSSAPIConsoleDriverclass.GSSAPI Console provides a [YALPT](https://pypi.python.org/pypi/yalpt) environment driver for
writing tutorials and literate python files involving GSSAPI.  You can use it by passing-e gssapito YALPT (it will use the default GSSAPI Console driver in this case).
Package: gs-sdk
sdk实现sdk调用中mqtt,http,rpc如何写sdk调用其他服务http接口要写A服务的sdk，A服务提供了1个http接口login，确定参数，在方法中实现具体的调用，如调用地址，使用post/get/put/patch等，最后返回结果ret = SdkInterface.login(username="admin", password="c93ccd78b2076528346216b3b2f701e6", http_api_version="4.7.1")要写A服务的sdk，A服务提供了1个rpc接口，确定参数，在方法中实现具体的调用，如调用地址，console服务名，最后返回结果SdkInterface.query_check(data=param)要写A服务的sdk，A服务需要一个topic，定义topic数据结构,ret2 = SdkInterface.check(param=param)订阅A服务topic,  定义回调函数，在回调函数中处理数据SdkInterface.test_subscribe(lambda client, userdata, msg: print(msg.payload))包制作https://zhuanlan.zhihu.com/p/79164800python3.9 -m pip install --user --upgrade setuptools wheel twinepython3.9 setup.py sdist bdist_wheelpython3.9 -m twine upload --repository-urlhttps://upload.pypi.org/legacy/dist/*
Package: gsselect
GSselectThis repository provides a python example of using the
Gemini Observatory API for triggering template observations
that are On Hold. Details of the ToO activation process are
givenhere.
The documenturltoo_readme.txtgive more details about the API.The example triggering script is urltrigger.py but most of the
code is for selecting a guide star. The triggering API does
not support the new automated guide star selection features
in the Observing Tool. The script gsselect.py mimics these
features and should find an appropriate guide star if one is
available in the UCAC4 catalog. It can also display the guide
star candidates and the wavefront sensor field of view on a
DDS image of the field.Gsselect also has a 'find' position angle (PA) feature
that we never implemented in the OT. This will pick the best guide
star available and set the PA so that it is reachable. This is
useful with the GMOS and F2 OIWFS guide probes if the PA
is unimportant.InstallationThe scripts require a standard Python distribution that includes
numpy (at least 1.15.4), matplotlib, astropy, and requests.Then install the scripts by downloading and unpacking the zip
file or use git, e.g.git clonehttps://github.com/bryanmiller/gsselect.gitThe gsselect guide star selection routines can also be installed as a pip package withpip install gsselectAuthenticationAuthentication for the trigger requires a 'user key' for the
Observing Tool that is associated with an email address that
is included in the active program. Seethis pagefor more information on user keys and how to obtain one.
Package: gssetting
gssettingAboutgssetting is load setting value from Google Sheets.InstallationTo install gssetting, use pip.pipinstallgssettingExamplesGoogle Sheets example.AnameemptyvalueBtest1nonevalueCtest2okvalue okSample codefromdataclassesimportdataclassfromgssettingimportGoogleSpreadSheetSetting,GSSetting@dataclassclassSetting(GSSetting):username:strvalue:str# Same header value of sheetsheaders=["name","value"]if__name__=="__main__":gs_setting=GoogleSpreadSheetSetting("./service_account.json","document_id")settings=gs_setting.load("sheet_name","A1:C3",Setting)print(settings)forsettinginsettings:print(setting.username.value)
Package: gssheet26
GSSHEET26IntroductionThis is an python package which helps us to read the data of google spread sheetsLibrary UsedI have used thegspreadandoauth2clientservice to authorize and make API calls to Google Cloud Services.Importing Librarypipinstallgspreadoauth2clientFeatures ofgspreadlibraryGoogle Sheets API v4.Open a spreadsheet by title, key or url.Read, write, and format cell ranges.Sharing and access control.Batching updates.Aboutoauth2clientThis library will help us to get the client credientials a to read the data of specific Spread Sheet.LET'S GET STARTEDHow to Installpipinstallgssheet26The name of this package is "gssheet26" and you can use this package to read the data fromGOOGLE SPREADSHEETSinJSONformat and then usingpandasyou can manipulate the data in table usingDataFramesFunction to read the dataTo read the data from google spreadsheet you have to usegetdata(jsfile, gsfile)function and inside the function you have to give the path of yourJSONfile and the name of yourGOOGLE SPREADSHEETS.
For example:- I want to read the data fromGreendeckAssignment file. So Here How it should be written.getdata("your_JSON_Path","Greendeck Assignment")### Links from where I've taken help 
 [medium.com](https://medium.com/analytics-vidhya/how-to-read-and-write-data-to-google-spreadsheet-using-python-ebf54d51a72c). 

# License

This package is distributed under the [MIT license](https://opensource.org/licenses/MIT).
Package: gssnng
gssnngGene Set Scoring on the Nearest Neighbor Graph (gssnng) for Single Cell RNA-seq (scRNA-seq).This package works with Scanpy AnnData objects stored as h5ad files.Read the Docs!Notebook using gmt files  ===>>>Notebook using Decoupler/Omnipath style API ===>>>**Notebook for smoothing counts. COMING SOON! For now, see the example script in test.See the paper ===>>>gssnngThe GSSNNG method is based on using the nearest neighbor graph of cells for data smoothing. This essentially creates
mini-pseudobulk expression profiles for each cell, which can be scored by using single sample gene set scoring
methods often associated with bulk RNA-seq.Nearest neighbor graphs (NNG) are constructed based on user defined groups (see the 'groupby' parameter below).
The defined groups can be processed in parallel, speeding up the calculations. For example, a NNG could be
constructed within each cluster or jointly by clusterandsample. Smoothing can be performed using either the
adjacency matrix (all 1s) or the weighted graph to give less weight to more distant cells.
Package: gssurgo
gssurgoThegssurgopython package enables open source workflows with thegSSURGOdataset. It provides:A shell scriptextract_gssurgo_tiffor generating stand-alonegSSURGOgrids.These raster grids are distributed within file geodatabase archives and can only be extracted using ArcGIS, the fileGDB driver, or (in the case ofextract_gssurgo_tif) thearcpypython package.Python functions for converting Geodatabase files to geopackage format.Python functions for returning the results of specificSQLqueries ofgSSURGOdata.Python functions for referencing query results to corresponding (raster) grid cells.PrereqsThe intialtif(grid) extraction step requies thearcpypython module. This step assumes that a python executable linked toarcpycan be found atC:\Python27\ArcGIS10.3\python.exe. Editbin/extract_gssurgo_tifto enable alternate locations.Remaining operations require the dependencies listed inenvironment.ymlandrequirements.txt. If using Anaconda, make sure you have the64bitversion. You can install an Anaconda virtual environment with:conda env create -n gssurgo -f environment.yml
source activate gssurgoInstallation# local install
# pip install -e  . 

# development install 
pip install git+git://github.com/jsta/gssurgo.git

# development upgrade
# pip install --upgrade git+git://github.com/jsta/gssurgo.gitUsageA demonstration workflow using thegssurgopython package can be found at:https://github.com/jsta/gssurgo_data1. Extract tif and build gpkgsextract_gssurgo_tif 'path/to/gSSURGO_STATE.gdb/MapunitRaster_10m' 'path/to/STATE.tif'importgssurgogssurgo.build_gpkg("path/to/gSSURGO_STATE.gdb","path/to/gSSURGO_STATE.gpkg")2. Generate an Area of Interest (AOI)gssurgo.aoi(in_raster_path="tifs",out_raster="path/to/aoi.tif",xmax=-88.34945,xmin=-88.35470,ymin=38.70095,ymax=38.70498)3. Pull specific variable and merge with corresponding tifgssurgo.query_gpkg(src_tif="tests/aoi.tif",gpkg_path="path/to/gkpgs/",sql_query='SELECT mukey, nonirryield_r FROM mucropyld WHERE (cropname = "Corn")',out_raster="tests/aoi_results.tif")gssurgo.query_gpkg(src_tif="tests/aoi.tif",gpkg_path="path/to/gpkgs/",sql_query='SELECT mukey, nonirryield_r FROM mucropyld WHERE (cropname = "Corn")',out_raster="tests/aoi_results.tif")Thesql_queryparameter must give a two column result ofmukeyandsome_variablewhere nomukeyentries are duplicated.4. Visualize outputgssurgo.viz_numeric_output("path/to/aoi_results.tif","path/to/aoi_results.png")
Package: gstack
DescriptionApache Cloudstack is open source software designed to deploy and manage large networks of virtual machines, as highly available, highly scalable Infrastructure as a Service(laaS) cloud computing platform. Apache Cloudstack is used by a number of service providers to offer public cloud services, and by many companies to provide an on-premises (private) cloud offering.Users can manage their Apache Cloudstack cloud with an easy to use web interface, command line tools and/or a full featured RESTful API.Google Compute Engine is the Infrastructure as a Service (IaaS) component of Google Cloud Platform which is built on the global infrastructure that runs Google’s search engine, Gmail, YouTube and other services. Google Compute Engine enables users to launch virtual machines on demand.Bridging Apache Cloudstack with existing public cloud providers APIs is needed in order to help users work across clouds. Our project’s aim is to create an application that will sit above the Apache Cloudstack API. The application will take in common Google Compute Engine requests, execute the necessary Cloudstack Calls and parse the responses as required. This would allow utilities created for the Google Compute Engine API to be used against Apache Cloudstack.UsagePlease see the project wiki for usage instructions (https://github.com/NOPping/gstack/wiki)
Package: gstatsd
gstatsd - A statsd service implementation in Python + gevent.If you are unfamiliar with statsd, you can readwhy statsd exists,
or look at theNodeJS statsd implementation.License:Apache 2.0RequirementsPython- I’m testing on 2.6/2.7 at
the moment.gevent- A libevent wrapper.distribute- (or
setuptools) for builds.Using gstatsdShow gstatsd help:% gstatsd -hOptions:Usage: gstatsd [options]

 A statsd service in Python + gevent.

Options:
  --version             show program's version number and exit
  -b BIND_ADDR, --bind=BIND_ADDR
                        bind [host]:port (host defaults to '')
  -s SINK, --sink=SINK  a graphite service to which stats are sent
                        ([host]:port).
  -v                    increase verbosity (currently used for debugging)
  -f INTERVAL, --flush=INTERVAL
                        flush interval, in seconds (default 10)
  -p PERCENT, --percent=PERCENT
                        percent threshold (default 90)
  -D, --daemonize       daemonize the service
  -h, --helpStart gstatsd listening on the default port 8125, and send stats to
graphite server on port 2003 every 5 seconds:% gstatsd -s 2003 -f 5Bind listener to host ‘foo’ port 8126, and send stats to the
Graphite server on host ‘bar’ port 2003 every 20 seconds:% gstatsd -b foo:8126 -s bar:2003 -f 20To send the stats to multiple graphite servers, specify ‘-s’
multiple times:% gstatsd -b :8125 -s stats1:2003 -s stats2:2004Using the clientThe code example below demonstrates using the low-level client
interface:from gstatsd import client

# location of the statsd server
hostport = ('', 8125)

raw = client.StatsClient(hostport)

# add 1 to the 'foo' bucket
raw.increment('foo')

# timer 'bar' took 25ms to complete
raw.timer('bar', 25)You may prefer to use the stateful client:# wraps the raw client
cli = client.Stats(raw)

timer = cli.get_timer('foo')
timer.start()

... do some work ..

# when .stop() is called, the stat is sent to the server
timer.stop()