Saravanan666/pypi-org huggingface dataset:
Package: gossh-python
gossh-pythonThis library bindscrypto/sshfor use in Python3
usinggopy.VersionsAll versions 1.0.0 and up support Python 3 only! If you need Python 2 support, check out the following:https://github.com/ftpsolutions/gossh-python/tree/v0.91https://pypi.org/project/gossh-python/0.91/ConceptIn the early daysgopywas fairly limited in it's ability to track object allocation across the border of Go and Python.As a result, our implementation is fairly naive- we only pass primitive types from Go to Python (nothing that comes by reference).Session are managed entirely on the Go side and identified with an integer- here are a few function signatures to demonstrate:NewRPCSession(hostname, username, password string, port, timeout int) uint64RPCConnect(sessionID uint64) errorRPCGetShell(sessionID uint64, terminal string, height, width int) errorRPCRead(sessionID uint64, size int) (string, error)RPCWrite(sessionID uint64, data string) errorRPCClose(sessionID uint64) errorThe functions that return complex data do so in a special JSON-based format- at this pointgopydoes it's magic and those functions are
made available to Python.We then haveRPCSessionabstraction on the Python side that pulls things together in a class for convenience (saving you need the to keep
track of the identifiers and handling deserialisation).Weird gotchasWe're building for Python3 and we use apython-configscript for Python3 however we're using apython.pcfile from Python2.I dunno why this has to be this way, but it's the only way I can get the C Python API GIL lock/unlock calls to be available to
Go (C.PyEval_SaveThread()andC.PyEval_RestoreThread(tState)).So if you're wondering why Python2 still comes into it here and there- that's why. Doesn't seem to cause any problems.PrerequisitesMacOSCPython3.8+virtualenvpip install virtualenvpkgconfigbrew install pkg-configDockerInstall (from PyPI)python -m pip install gossh-pythonSetupvirtualenv -p $(which python3) venv
source venv/bin/activate
./fix_venv.sh
pip install -r requirements-dev.txtBuildsource venv/bin/activate
./native_build.shIf you're deep in the grind and want to iterate faster, you can invoke:./native_build.sh fastThis skips the setup (assuming you've already done that).
Package: gossipcat
😸😹😺😻😼😽😾😿🙀🐱GossipCatis a data science project framework that simplifies the process of machine learning from data cleaning, simple feature engineering, machine learning algorithm comparison, hyper parameter tuning, model evaluation, to results output. It is designed to be efficient with following features:Agile machine learning framework: designed with a lean start and continuing improvement.Pipeline data preprocessing: high cohesion, low coupling.Algorithms comparison: provides a overview of multiple machine learning algorithms comparison.Diverse model evaluation: makes the evaluation visible and with business sense.Architectural thinking: not only data science but also machine learning engineering.Story of the GossipCatThe package names after a cat of my friend, LEEverpool.LicenseGossipCat is licensed under the Apache License 2.0. © Contributors, 2023.A permissive license whose main conditions require preservation of copyright and license notices. Contributors provide an express grant of patent rights. Licensed works, modifications, and larger works may be distributed under different terms and without source code.
Package: gossip-python
Team:Shackle CrackdownMembers:Thomas Maier (ga85how@mytum.de)Anselm Binninger (ga85dib@mytum.de)Ralph O. Schaumann (ga65gis@mytum.de)Group no:09Sub-project:GossipTable of Contents1Installation2Basic Use3Examples1InstallationTODO2Basic UseTODO3ExamplesTODO
Package: go-stats
go-stats python toolGenerate statistics for a GO release based on a GOLr instanceInstallpip install go-statsContentThis package contains several scripts used to compute both statistics and changes of Gene Ontology releases.go_stats.py: compute the stats for a given releasego_ontology_changes.py: compute the changes for two releases (using OBO files)go_annotation_changes.py: compute the changes for two releases (using 1 GOLr instance and previously computed stats)go_refine_stats.py: used to compute the first stats, including ontology statsgo_reports.py: used to compute all stats and changes between two releasesUsageimport go_stats

release_date = '2019-09-01'
include_protein_binding = False

json_stats = go_stats.compute_stats('http://golr-aux.geneontology.io/solr/', release_date, include_protein_binding)
go_stats.write_json("stats.json", json_stats)

tsv_stats = go_stats.create_text_report(json_stats)
go_stats.write_text("stats.tsv", tsv_stats)

json_meta = go_stats.create_meta(json_stats)
go_stats.write_json("meta.json", json_meta)Notescurrent GOLr instance ishttp://golr-aux.geneontology.io/solr/older GOLr archives are stored in zenodo both asfull archiveandreference archivewhich can be used withbdbagsto retrieve only the golr database dump (golr-index-contents.tgz)several scripts will be refactored and simplified (e.g. go_refine_stats.py is used to compute the first set of stats files, then for the next releases one can use go_reports.py)
Package: gostep
Developed withJetBrainsPyCharm💓gostepServerless Templates Provider for Google cloud platform.Prerequisitespython v3.xSubversion CLIgcloud SDKHow to installFrom PyPIpipinstallgostepFrom sourceSimply clone the repository or download source.cdgostep
pythonsetupinstallCLI HelpSimply use commandgostepto get the available command list.GuideFor more information please refer thewiki.LicenseMIT License
Copyright (c) 2018 Lahiru Pathirage and Codimite pvt ltd.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "gostep"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: gosttpy
Google Speech To Text for PythonPython module for speech recognition using Google’s speech recognition API.</br>
Tested in ubuntu 13.10 with python_2.7DependenciesFor LINUX - Please install the sox and simplejson with the following lines in your terminal:sudo  apt-get install sox

sudo  pip install simplejsonFor OSX you need to install Homebrew first and then the dependencies (PIP already comes with python so you might want to test in your terminal to verify your version) otherwise if you haven’t installed python yet please do with “sudo brew install python” as shown in the following lines:sudo ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"

sudo brew install sox

sudo brew install python

sudo pip install simplejsonHOW TO USEgosttPy module recieves a voice command from the user (through the microphone) and executes a google search…
It achieves this by recording a .flac audio file and uploading it to google’s speech
recognition engine which converts it into readable text. The output from google is a
JSON object with a list of posible interpretations/transcripts (translations from voice to text.A google speech API KEY will be needed for the module to work. Please get one from the google developers wesite:http://www.chromium.org/developers/how-tos/api-keysThe JSON object looks like this:{“result”:[{“alternative”:[{“transcript”:”world”,”confidence”:0.43871391},  {“transcript”:”World”},{“transcript”:”solo”},{“transcript”:”solo world”},{“transcript”:”so wharo”}],”final”:true}],”result_index”:0}The result of this operation becomes a google search engine query that outputs
some result related to the original voice command…The goosttPy module allows you to choose between different outputs:‘RAW’ –> Google’s speech API JSON object (Complete / not-parsed)raw-data‘FIRST’ –> Just the first transcripted version of your voice‘ALL’ –> The list of all the transcripts returned by the google speech API‘SEARCH’ –> includes the search result returned from googleExample / Usagepython code:from gosttpy import gosttpy # From the file goosttPy.py import the class goosttPy

speech = gosttpy.gosttpy()

# Google API key for voice recognition (Replace the string 'YOUR-GOOGLE-SPEECH-API-KEY' with
#your google API Key. Follow this link: http://www.chromium.org/developers/how-tos/api-keys
apiKey = 'YOUR-GOOGLE-SPEECH-API-KEY'

#returnType --> options are: 'RAW', 'FIRST', 'ALL', 'SEARCH'
returnType = 'FIRST'
returnedText = speech.voiceRecognitionAndSearch(apiKey, returnType)
print returnedText
Package: gostyle
GoStyleGo syntax implementation in Python.Installationpip install gostyleThreading Wrapper Like goRoutineIn GoLang, we can create parallel tasks via keywordgo://GoLang//...goXXXX(arg1,arg2)//...In GoLang, the thread creating has following features:The parameter passing is the same as the original function defined by user.The original function is still usable as defined.However, in Python creating a thread is stupid:#Python#...t=threading.Thread(target=XXX,args=(arg1,arg2))t.start()#...Recommended UsageUsage with best compatibility:importtimefromgostyleimportgo,Chanchan1=Chan()deftest_thread(title:str):forcntinrange(10):chan1<=cnttime.sleep(1)print(title)defchan_reader():whileTrue:print(chan1())# Start the threadgo(test_thread)("Call")chan_reader()How To Use Wordgoin PythonIf the function is self-defined, you can use decorator@gostyle.startable()like following:importtimeimportgostyle@gostyle.startable()deftest_thread(title:str):whileTrue:time.sleep(1)print(title)# Start the threadtest_thread.start("Start")# Note that the expression "test_thread('Normal')" can still run the original function in main thread.Or, if the function is not a class/object method:importtimeimportgostyle@gostyle.destination()deftest_thread(title:str):whileTrue:time.sleep(1)print(title)# Start the threadgostyle.to.test_thread("Go To Destination")# Note that the expression "test_thread('Normal')" can still run the original function in main thread.Or:importtimefromgostyleimportgo@go.goable()deftest_thread(title:str):whileTrue:time.sleep(1)print(title)# Start the threadgo.test_thread("Go")# Note that the expression "test_thread('Normal')" can still run the original function in main thread.If the function is not self-defined(you can not add decorator to the function), or the function is a method of a class/object(the function you defined is hard to attach to "go"(same as "to") object in this package), you can use syntax like following:importtimefromgostyleimportgodeftest_thread(title:str):whileTrue:time.sleep(1)print(title)# Start the threadgo(test_thread)("Call")Run-Forever and DaemonizeThedaemonparameter controls the deamon option in packagethreading. and the forever parameter lets you get rid of awhile True:expression in the function you defined.importtimefromgostyleimportgodeftest_thread(title:str):# No Internal WHILE Here.time.sleep(1)print(title)# Start the threadgo(test_thread,forever=True)("Call Forever")importtimeimportgostyle@gostyle.startable(forever=True)deftest_thread(title:str):# No Internal WHILE Here.time.sleep(1)print(title)# Start the threadtest_thread.start("Start Loop")DeferIn GoLang, defer is used to do things(usually cleaning-up) after a function returns.How To Use in PythonUsage of decoratordefer_inside:fromgostyleimportdefer_inside,defer@defer_insidedefgreat_func():a=[1,2,3]b=8defer(lambda:a.append(7),lambda:print(a),lambda:print(b))a.append(9)returna,bprint(great_func())TodosThreadingManage Threads started by gostyle
Collect return values
Single Instance support
Yield Support
Multithreading SupportDeferMulti-times Defer SupportQueueQueue WrapperSwitch...Anonymous Functions...
Package: gosundpy
gosundpyControl your Gosund smart devices via python code.InstallpipinstallgosundpyPrerequisitesIn order to control your devices, you must register your devices using the Tuya
Smart app (ios/android) and create a new Cloud Project in the Tuya
IoT Platform.UsageimporttimefromgosundpyimportGosundgosund=Gosund('username','password','access_id','access_key')commands=['turn_off','turn_on','turn_off','switch','switch','turn_off']switch=gosund.get_device('12345')forcmdincommands:getattr(switch,cmd)()time.sleep(1)lightbulb=gosund.get_device('67890')forcmdincommands:getattr(lightbulb,cmd)()time.sleep(1)
Package: go-task-bin
go-task-binhttps://github.com/go-task/taskhttps://taskfile.dev/Taskis a task runner / build tool that aims to be simpler and easier to use than, for example,GNU Make.Since it's written in Go, Task is just a single binary and has no other dependencies, which means you don't need to mess with any complicated install setups just to use a build tool.Onceinstalled, you just need to describe your build tasks using a simpleYAMLschema in a file called Taskfile.yml:Taskfile.yaml---version:'3'tasks:hello:cmds:-echo 'Hello World from Task!'silent:trueAnd call it by running task hello from your terminal.The above example is just the start, you can take a look at theusageguide to check the full schema documentation and Task features.This is a python wrapper that can be installed with pip.installpipinstallgo-task-bin
Package: gotcha
# Gotcha## OverviewGotcha is a python2 program that parse a source code to extract developers comments. These comments are written in a special format called Gotcha Keywords, and they are used to point in a formal way bugs in the code, parts of code that may be rewritten, documentation… Any kind of information useful for developpers.These gotcha keywords are very useful during the developping phase and they allow developers to track bugs and see the amount of remaining work in a blink of an eye. In fact, when we use Gotcha to display, for example, "TODO" comments, we can see the tasks we have to achieve to progress in the project. A search on the keyword "BUG" lists parts of the code that we have to debug and "TRICKY" comments are use to explain a part of code that might be hard to understand by only reading it.## Comments formatA comment Gotcha have to be written like that :CS :KEYWORD:dev-name:yyyymmdd:Comment"CS" stands for Comment Symbol. The keyword heve to be written uppercase. The date have to respect the format yyyymmdd.Example with a C comment :// :TODO:Meow:20121221:Find a way to survive to the end of the worldExemple with a shellscript comment :# :BUG:Meow:20120405:This function just don't work at all...## KeywordsHere is the list of the Gotcha Keywords that Gotcha is able to parse, and their sense:* BUG : Describes a bug in the code, with a brief description next line if possible* DEBUG : Indicate that a developer is working on the bug described before this comment* WARNING : Important information for developers, for example, to specify that a method is working but might be unsafe…* TODO : Describes a task to do* KLUDGE : Describes a piece of code that have to be rewritten before release (quick and dirty code)* TRICKY : Used to explain some technical code, hard to understand by only reading it.* DOC : Description of the code for documentation* COMMENT : A "classic" comment, that might stay after the releaseThese keywords are sorted in classes, here are the definitions:* Critical : Describes critical information, work that have to be done as soon as possible.* Important : Important informations, some tasks to do* Info : Informative comments that must stay in documentation* Notice : Notes, comments, …## How to use GotchaJust run gotcha. With -h to display all options available.Gotcha can display all gotcha keywords but also and moreover, information you want. We can specify files to parse, to ignore, tell him to parse every file in every sub-directory, on only in the current one. It is possible to filter results by keywords class, ignore some keywords, just display keywords you want to see. Finally we can also sort results by keyword, by developer name and by date. We can display information that suits our own needs.For more information I suggest you to start the program with the -h option. You will see all the options and some examples of use.## InstallYou can install Gotcha with pip : pip install gotcha## SourcesSources are freely available on github : http://github.com/meowstars/gotcha## LicenseGotcha is published under the LGPL version 3 license.
Package: go-template
Go-templateOverviewPython bindings for go text/templateQuickstartPipgo_templateworks Python 2.7, 3.5, 3.6, 3.7.pip install go_templateExampleContent of sample.tmpl{{.Count}} items are made of {{.Material}}Content of values.ymlCount: 12
Material: WoolPrint rendered output to stdout>>> import go_template
>>> go_template.render_template('tests/sample.tmpl','tests/values.yml','')
12 items are made of WoolGet rendered output in a file>>> import go_template
>>> go_template.render_template('tests/sample.tmpl','tests/values.yml','output.txt')Content of output.txt12 items are made of WoolNOTE: Paths provided to render_template should either be absolute path or relative to directory where it is ran.Build shared libraryFor building a fresh shared object of text/template, you must have golang^1.5 installed../build.shThis will createtemplate.soin thebindfolder.MotivationCurrently, there is no python package which exposes golangtext/templatefunctionality to python. And I am in the process of learning about interoperability between different languages. So, I started working on this as a learning project.ExplanationGolang library cannot be directly used in python. Firstly, we have to compile it as shared object or archive for interoperability with C. And then create python bindings for this C object.CPythonis the original Python implementation and provides cpython API for creating python wrapper, but the wrapping code is in C. There is a librarygopywhich exactly uses this approach. But it works only on go1.5 and for python2.If we want to write the wrapping code in python, there areCythonandctypes. Ctypes allow directly importing the C library and calling functions through its interface. This project usesctypesfor calling go functions.When a golang library is compiled as shared object,cgohandles exposing functions and data type conversion. Using ctypes, we can only modify simple data type, string, int, float, bool. I tried converting python class to golang struct, but it failed.So, I created a golang wrapper over text/template library, which takes simple datatypes. And handles complex operation in this layer. Then a python wrapper over this layer usingctypes.It is far from complete and doesn't use the best approach. Currently, it has only one function which takes path of template and value file. And depending on the third argument, either writes to stdout if empty  or to file if given its path.LicenseThis project is licensed underMITLicense.
Package: gotenberg-client
Gotenberg API ClientTable of ContentsInstallationWhatWhyFeaturesHowExamplesLicenseInstallationpip install gotenberg-clientWhatThis is a Python client for interfacing withGotenberg, which in turn is a wrapper around
powerful tools for PDF generation and creation in various ways, using a stateless API. It's a very powerful tool
to generate and manipulate PDFs.WhyAs far as I can tell, no active Python library exists to interface with the Gotenberg API.FeaturesHTTP/2 enabled by defaultAbstract away the handling of multi-part/form-data and deal withPaths insteadBased on the modernhttpxlibraryFull support for type hinting and concrete return types as much as possibleNearly full test coverage run against an actual Gotenberg server for multiple Python and PyPy versionsHowAll the routes and options from the Gotenberg routes are implemented, with the exception of the Prometheus metrics
endpoint. All the routes use the same format and general idea.First, you add the file or files you want to processThen, configure the endpoint with its various options the route supportsFinally, run the route and receive your resulting fileFiles will be PDF or ZIP, depending on what endpoint and its configuration. Endpoints which handle
multiple files, but don't merge them, return a ZIP archive of the resulting PDFsExamplesConverting a single HTML file into a PDF:fromgotenberg_clientimportGotenbergClientwithGotenbergClient("http://localhost:3000")asclient:withclient.chromium.html_to_pdf()asroute:response=route.index("my-index.html").run()Path("my-index.pdf").write_bytes(response.content)Converting an HTML file with additional resources into a PDF:fromgotenberg_clientimportGotenbergClientwithGotenbergClient("http://localhost:3000")asclient:withclient.chromium.html_to_pdf()asroute:response=route.index("my-index.html").resource("image.png").resource("style.css").run()Path("my-index.pdf").write_bytes(response.content)Converting an HTML file with additional resources into a PDF/A1a format:fromgotenberg_clientimportGotenbergClientfromgotenberg_client.optionsimportPdfAFormatwithGotenbergClient("http://localhost:3000")asclient:withclient.chromium.html_to_pdf()asroute:response=route.index("my-index.html").resources(["image.png","style.css"]).pdf_format(PdfAFormat.A1a).run()Path("my-index.pdf").write_bytes(response.content)Converting a URL into PDF, in landscape formatfromgotenberg_clientimportGotenbergClientfromgotenberg_client.optionsimportPageOrientationwithGotenbergClient("http://localhost:3000")asclient:withclient.chromium.url_to_pdf()asroute:response=route.url("https://hello.world").orient(PageOrientation.Landscape).run()Path("my-world.pdf").write_bytes(response.content)To ensure the proper clean up of all used resources, both the client and the route(s) should be
used as context manager. If for some reason you cannot, you should.closethe client and any
routes:fromgotenberg_clientimportGotenbergClienttry:client=GotenbergClient("http://localhost:3000")try:route=client.merge(["myfile.pdf","otherfile.pdf"]).run()finally:route.close()finally:client.close()Licensegotenberg-clientis distributed under the terms of theMPL 2.0license.
Package: gotenshita
See Gotenshita court open status.
The information is got fromundoukai.Installpip install gotenshitaUsage% gotenshita -h
usage: gotenshita [-h] [-p] [-t] [court]

positional arguments:
  court            A to F (default is all), supports multiple select like
                   'a,f'

optional arguments:
  -h, --help       show this help message and exit
  -p, --show-past  show even if past time
  -t, --tomorrow   show tomorrow's dataLicenseCopyright (C) 2015-2016 Kentaro WadaReleased under the MIT licensehttp://opensource.org/licenses/mit-license.php
Package: gotext
GoText v0.9GoText is a universal text extraction and preprocessing tool for python which supportss wide variety of document formats.Installpip install gotextHow To UsefromgotextimportGoDocument# process single documentdoc_path='docs/test.docx'go_obj=GoDocument(doc_path=doc_path)print(go_obj._text)#returns text extracted from documentprint(go_obj.preprocess())#preprocess document and returns preprocessed text#process all the documents within a directorydocs_dir='docs/'go_obj=GoDocument(docs_dir=docs_dir)print(go_obj._text)#returns a list of texts extracted from all the documentsprint(go_obj.preprocess())#preprocess documents and returns a list of preprocessed textFeedback / QueriesFor any queries or feedback feel free to write tovaibhavhaswani@gmail.com
Package: gothresher
GOThresher removes annotation bias from GAF files based on GO term information content, GO evidence, annotation source, number of proteins annotated from a given source, and date. GOThresher accepts one or more GAF files as input. The motivation for GOThresher lies in the observation that protein function annotations are biased due to high throughput experimental studies. Removing such annotation biases can help present a more balanced picture of protein annotations for a given organism or set of proteins.