Saravanan666/pypi-org huggingface dataset:
Package: gobbli
This is a library designed to provide a uniform interface to various deep learning models for text via programmatically created Docker containers.UsageSeethe docsfor prerequisites, a quickstart, and the API reference.  In brief, you needDockerinstalled with appropriate permissions for your user account to run Docker commands and Python 3.7.  Then run the following:pip install gobbliYou may also want to check out thebenchmarksto see some comparisons of gobbli's implementation of various models in different situations.Interactivegobbli providesstreamlitapps to perform some interactive tasks in a web browser, such as data exploration and model evaluation.  Once you've installed the library, you can run the bundled apps using thegobblicommand line application.  Checkthe docsfor more information.DevelopmentAssuming you have all prerequisites noted above, you need to install the package and all required + optional dependencies in development mode:pip install -e ".[augment,tokenize,interactive]"Install additional dev dependencies:pip install -r requirements.txtRun linting, autoformatting, and tests:./run_ci.shTo avoid manually fixing some of these errors, consider enablingisortandblacksupport in your favorite editor.If you're running tests in an environment with less than 12GB of memory, you'll want to pass the--low-resourceargument when running tests to avoid out of memory errors.NOTE:If running on a Mac, even with adequate memory available, you may encounter Out of Memory errors (exit status 137) when running the tests.  This is due to not enough memory being allocated to your Docker daemon.  Try going to Docker for Mac -> Preferences -> Advanced and raising "Memory" to 12GiB or more.If you want to run the tests GPU(s) enabled, see the--use-gpuand--nvidia-visible-devicesarguments underpy.test --help.  If your local machine doesn't have an NVIDIA GPU, but you have access to one that does via SSH, you can use thetest_remote_gpu.shscript to run the tests with GPU enabled over SSH.DocsTo generate the docs, install the docs requirements:pip install -r docs/requirements.txtSince doc structure is auto-generated from the library, you must have the library (and all its dependencies) installed as well.Then, run the following from the repository root:./generate_docs.shThen browse the generated documentation indocs/_build/html.Attributiongobbli wouldn't exist without the public release of several state-of-the-art models.  The library incorporates:BERT, released by GoogleMT-DNN, released by MicrosoftUniversal Sentence Encoder, released by GooglefastText, released by Facebooktransformers, released by Hugging FacespaCy, by Explosionscikit-learnOriginal work on the library was funded byRTI International.Logo design byMarcia Underwood.
Package: gobits
DescriptionGobits is a very small module, which acts as a metadata carrier within an event-driven architecture on the Google Cloud Platform (GCP).
It automatically adds fields that may be useful downstream to determine the origin of a message.UsageClass attributes:classGobits:"""A small class that gathers information (bits) for a pub/sub message payload.Attributes:_request                Holds information about the cloud function request._context                Holds information about the cloud function context.envelope                The envelope containing a pub/sub message.message                 The pub/sub message to be processed.processed               Time of processing (UTC).gcp_project             The source GCP project.execution_id            The id of the execution.execution_type          Type of the service processing the message.execution_trigger_type  Type of the trigger invoking the processor.function_name           Name of the processing cloud function.function_version        Version of the processing cloud function.event_id                The id of the trigger event.message_id              The pub/sub message id.message_publish_time    Time of publishing to pub/sub (UTC).source_subscription     The originating pub/sub subscription."""Cloud function with HTTP trigger:fromgobitsimportGobitsdefhandler(request):metadata=Gobits.from_request(request=request)message={'gobits':[metadata.to_json()],'data':[]}Cloud function with other trigger:fromgobitsimportGobitsdefhandler(data,context):metadata=Gobits.from_context(context=context)message={'gobits':[metadata.to_json()],'data':[]}TestingSometimes you want to test a cloud function locally. Be sure to pass mock objects containing the correct fields (if applicable).frommainimporthandlerfromunittest.mockimportMockmock_data=Mock()mock_context=Mock()mock_context.event_id="12345678"handler(mock_data,mock_context)
Package: gobjectservicelib
GObject mainloop enabled version ofhttps://gitlab.com/advian-oss/python-datastreamservicelib(runs GObject mainloop in a thread, asyncio is still the main threads mainloop).Notable helpersServiceWidgetBase/ServiceWindowBase (in widgets.py) and the aio decorator (in eventloop.py), the first should be used
as baseclass for your own widgets/windows that need a reference to the main service and aio mainloop.
The latter is a decorator that can be applied to a method of subclass of ServiceWidgetBase to
make said method run in the aio mainloop.And of course the GObject mainloop enabled SimpleService which extends the one in datastreamservicelibDockerThis depends on GObject libraries etc from the operating system level, easiest way
to get hacking is to build the docker image and work inside it.SSH agent forwardingWe needbuildkit:export DOCKER_BUILDKIT=1And also the exact way for forwarding agent to running instance is different on OSX:export DOCKER_SSHAGENT="-v /run/host-services/ssh-auth.sock:/run/host-services/ssh-auth.sock -e SSH_AUTH_SOCK=/run/host-services/ssh-auth.sock"and Linux:export DOCKER_SSHAGENT="-v $SSH_AUTH_SOCK:$SSH_AUTH_SOCK -e SSH_AUTH_SOCK"Creating the containerMake sure you have defined DOCKER_DISPLAY above.Build image, create container and start it:docker build --progress plain --ssh default --target devel_shell -t gobjectservicelib:devel_shell .
docker create --name gobjectservicelib_devel -v `pwd`":/app" -it  -v /tmp:/tmp `echo $DOCKER_SSHAGENT` gobjectservicelib:devel_shell
docker start -i gobjectservicelib_develThis will give you a shell with system level dependencies installed, you should do any shell things (like
run tests, pre-commit checks etc) there.pre-commit considerationsIf working in Docker instead of native env you need to run the pre-commit checks in docker too:docker exec -i gobjectservicelib_devel /bin/bash -c "pre-commit install"
docker exec -i gobjectservicelib_devel /bin/bash -c "pre-commit run --all-files"You need to have the container running, see above. Or alternatively use the docker run syntax but using
the running container is faster:docker run --rm -v `pwd`":/app" gobjectservicelib:devel_shell -c "pre-commit run --all-files"Test suiteYou can use the devel shell to run py.test when doing development, for CI use
the “test” target in the Dockerfile:docker build --progress plain --ssh default --target tox -t gobjectservicelib:tox .
docker run --rm -it -v `pwd`":/app" `echo $DOCKER_SSHAGENT` gobjectservicelib:toxLocal DevelopmentTLDR:Check dockerfile for system dependencies and adapt according to your envCreate and activate a Python 3.7 virtualenv (assuming virtualenvwrapper):mkvirtualenv -p `which python3.7` my_virtualenvchange to a branch:git checkout -b my_branchinstall Poetry:https://python-poetry.org/docs/#installationInstall project deps and pre-commit hooks:poetry install
pre-commit install
pre-commit run --all-filesReady to go.Remember to activate your virtualenv whenever working on the repo, this is needed
because pylint and mypy pre-commit hooks use the “system” python for now (because reasons).
Package: goblet
Goblet is a fast, easy to customize web frontend for git repositories. It was
created because existing alternatives are either not very easy to customize
(gitweb), require C programming to do so (cgit), or are tied into other
products, such as bugtrackers (redmin, github).Goblet is currently in alpha status, so not all goals have been met yet.
Contributions are welcome, the most useful contribution is using it and
reporting all issues you have.If you want to see goblet in action, you can find a running instance on
git.kaarsemaker.net. If you like what you see, proceed to read docs/install.rst
and enjoy!Should you hit a problem installing or using goblet, please report it on
github. Reports about uncaught python exceptions should include full
backtraces. If the repository triggering the bug/issue is public, please
include a link to the repository and the link to the bug so I can reproduce it.
Package: goblet-workflows
Goblet Workflows (Beta)Goblet Workflows is a wrapper aroundGCP Workflows, which is a fully-managed orchestration platform that executes services in an order that you define: a workflow. These workflows can combine services including custom services hosted on Cloud Run or Cloud Functions, Google Cloud services such as Cloud Vision AI and BigQuery, and any HTTP-based API.While GCP Workflows is powerful, it requires learning a complex yaml DSL, which makes it hard to manage and scale, and has a steap learning curve to get started.Goblet Workflows uses similar syntax that you can expect from airflow and prefect, to make it easy to write, deploy, and manager your workflows, while leveraging the severless nature of GCP workflows.See below for a simple workflow example.fromgoblet_workflows.workflowimportWorkflowfromgoblet_workflows.stepsimportAssignStep,BQStepw=Workflow("bigquery-step-example",params=["column"])upack_args=AssignStep(w,"upack_args",column="${column}")bq_step=BQStep(w,"bq_step","select{column}from DATASET limit 1")bq_step_2=BQStep(w,"bq_step_2","select colomn2 from DATASET2 where column1 ={bq_step[0]}")upack_args>bq_step>bq_step_2Not to deploy you simply have to run the commandgoblet_workflows deploy, which will yield the workflow below.Getting startedTo install run:pip install goblet_workflowsTo deploy a workflow create amain.pyfile where you define your workflow and steps.Then rungoblet_workflows deployTo view the yaml rungoblet_workflows printTo execute a workflow rungoblet_workflows executeTo execute a workflow run with an arggoblet_workflows execute --arg '{"project_id":"PROJECT","var1":"xx"}'ExamplesGoblet Workflow ExamplesFeaturesGeneric StepsBranchesDeployment of Workflows and SchedulesGCP ConnectorsExecute WorkflowsGCP WorkflowsOverviewSyntax Cheat SheetIssuesPlease file any issues, bugs or feature requests as an issue on ourGitHubpage.Roadmap☑ Http Steps☑ GCP Generic Connectors☑ BQ Connector☑ Dataform Connector☑ Deploy☑ Deploy Arbitrary File☑ Execute☐ Delete☑ Schedule☐ Conditions☐ Subworkflows☐ Parameter typingWant to ContributeIf you would like to contribute to the library (e.g. by improving the documentation, solving a bug or adding a cool new feature) submit apull request.
Package: goblinoid
ConvertGoblinOGM to JanusGraph schema.This tool provides an automated way to keep your graph database schema in sync withGoblinOGM (Object Graph Mapper). Once you define your schema using Goblin’s Vertex and Edge classes you can simply pass sources to Goblinoid that will automatically create a groovy script you can run to create your graph database schema.InstallationYou can simply install Goblinoid fromPyPI:$pip3installgoblinoidOnce your Goblinoid is installed you can access its CLI using:$goblinoid--helpUsage - Schema creationGoblinoid allows you to automatically create schema based on models defined in your source code. To automatically generate schema definition, you need to point Goblinoid to the correct module of your application that holds all defined models for your application:$goblinoid-cli--module-import'myapp.graph.models'--models-iterable'ALL_MODELS'--schema-fileschema.groovyTipBy using one iterable (e.g. tuple), you can directly reuse this iterable for theGoblin’s registermethod to keep your models always in sync in your application:app=awaitGoblin.open(loop,hosts=['localhost'],port=port,))app.register(*tuple(ALL_MODELS))It’s important to state that your package/module is importable for the CLI (you might want to adjustPYTHONPATHto accomplish that in some cases). Goblinoid automatically creates a Groovy script that you can run to create schema.It isrecommendedto also provide the--schema-vertex-identifieroption. In that case Goblinoid automatically creates a vertex with labelgoblinoid_schema_metathat holds providedidentifieranddatetimewhen the schema creation was performed. This allows you to keep graph metadata for later debugging or ensuring your services that communicate with the graph instance use required schema version.By default, Goblinoid disables JanusGraph’s schema maker. It isrecommendedhaving the schema maker disabled so all vertexes and edges that are added to the graph database respect the provided schema and there are not created additional schema entries. You can avoid this behaviour by specifying the--keep-schema-makerflag. See theofficial documentationfor more info.
Package: goblinpass
Installation$ pip install goblinpass && goblinFeaturesgoblin, ** Goblin Pass Generator **How to install ?$ pkg install python -y
$ pip install goblinpass
$ goblinRun ?$ goblinDisclaimerWe are not responsible for your loss.
this tool is made for Education/Learning Purpose.
Dont harm anyone using this tool.Usage$ goblin -h

Author : UndeadSec
PIP module : Parixit Sutariya
Github : github.com/Bhai4You
Blogspot : https://bhai4you.blogspot.comGithub
Package: gobnb
Airbnb scraper in PythonOverviewThis project is an open-source tool developed in Python for extracting product information from Airbnb. It's designed to be easy to use, making it an ideal solution for developers looking for Airbnb product data.FeaturesFull search supportExtracts detailed product information from AirbnbImplemented in Python just because it's popularEasy to integrate with existing Python projectsThe code is optimize to work on this format:https://www.airbnb.com/rooms/[roomID]Install$pipinstallgobnbExamplesimportgobnbimportjsoncurrency="MXN"check_in="2024-03-11"check_out="2024-03-14"ne_lat=-1.1225978433925647ne_long=-77.59713412765507sw_lat=-1.03866277790021sw_long=-77.53091734683608zoom_value=2results=gobnb.Search_all(check_in,check_out,ne_lat,ne_long,sw_lat,sw_long,zoom_value,currency,"")details_data=[]progress=1jsondata=json.dumps(results)f=open("results.json","w")f.write(jsondata)f.close()forresultinresults[:10]:data=gobnb.Get_from_room_id(result["room_id"],currency,"")details_data.append(data)print("len results: ",progress,len(results))progress=progress+1details_data_json=json.dumps(details_data)f=open("details_data.json","w")f.write(details_data_json)f.close()importgobnbimportjsonroom_url="https://www.airbnb.com/rooms/[room_id]"currency="USD"data=gobnb.Get_from_room_url(room_url,currency,"")jsondata=json.dumps(data)f=open("details.json","w")f.write(jsondata)f.close()importgobnbimportjsonroom_id=0#obviously the room idcurrency="MXN"data=gobnb.Get_from_room_id(room_id,currency,"")jsondata=json.dumps(data)f=open("details.json","w")f.write(jsondata)f.close()
Package: gobomatic
GobomaticGobomatic is a Python library to generate Scratch (3>) projects from
Object-Oriented representation of Scratch projects in Python code.ExampleA build.py file is used to build the Scratch project. It also defines the Stage
sprite.build.pyfromgobomaticimport*frommainimportSelfasmainstage=Sprite("Stage",costumes=["assets/blank.svg"])Self=Project(sprites=[stage,main])Self.export("project.sb3",debug=True)Each sprite is defined in its own Python file.main.pyfromgobomaticimport*Self=Sprite(name=__name__,costumes=["assets/scratchcat.svg"])Self.WhenFlagClicked(Goto(-100,0),Glide(0,0,0.5),Say("Hello, World!"),)Resulting project codeDocumentation~/docs/docs.mdContributingYou can help with the development of gobomatic by testing or writing documentation.Installation from sourceclone the repository (You should fork the repository first!)cd ~/Projects
git clone https://github.com/aspizu/gobomatic gobomatic-gitinstall the module in edit modecd gobomatic-git
pip install -e .TestingUse~/examples/testingto test various Scratch code.building the projectcd examples/testing
python build.pyopen testing.sb3 in the Scratch editor to examine the result.MentionsThanks to@DavidBuchanan314, They too are working on a similar project but with different goalsboigawhich was the inspiration for this project.
Package: goby
This directory contains the Python API for reading binary data files
created using the Goby next-gen data management framework.Normally, this directory comes as part of the complete Goby package,
available from:http://goby.campagnelab.org/The complete package includes the Java source code.  If you downloaded
this package from PyPI or some other Python-specific source, you may
have received only the Python part of the code.Development WarningThe Goby Python libraries are not as mature as the Java
implementation.  It may be more buggy and is not intended to provide
the complete set of features that are found in the Java version.InstallationMake sure you have Python 2.5 or newer.  If in doubt, run:$ python -VDownload and install the prerequisite python packages:Protocol BuffersAvailable fromhttp://code.google.com/p/protobuf/or PyPIpyjavaproperties - Python replacement for java.util.PropertiesAvailable fromhttp://pypi.python.org/pypi/pyjavapropertiesInstall the Goby package:$ python setup.py installThis step may require superuser privileges.UsageExample scripts are provided to demonstrate how to access the content
of Goby files in Python.Here is how to scan a Goby alignment file:GobyAlignmentStats.py basename(The files basename.entries and basename.header must exit.)The next command will print the content of an alignment file as text:GobyAlignmentToText.py basenameThe next command will convert a compact reads file to fasta format:GobyCompactToFasta.py file.compact-readsThe next command will print statistics about the content of a
compact reads file:GobyReadsStats.py file.compact-readsDocumentationThe complete documentation for Goby is available online at:http://goby.campagnelab.org/
Package: goby-sdk
GOBY SDK for PythonGOBY SDK for Python是一个非官方版本的GOBY SDK，基于 goby-x64-2.4.5-Community 进行开发。该SDK旨在解决企业系统快速集成GOBY扫描引擎的问题。详细SDK文档请访问：https://www.exp-9.com/category-20.html或https://github.com/siberiah0h/goby_sdk_for_python。API接口列表以下是一些API接口及其含义的列表：get_poc_list函数：获取POC列表start_scan函数：开始扫描resume_scan函数：恢复扫描stop_scan函数：停止扫描get_scan_progress函数：获取扫描进度get_tasks函数：获取任务get_statistics_data函数：获取统计数据asset_search函数：资产搜索get_value_category函数：获取值分类get_children_category函数：获取子分类get_ip_info函数：获取IP信息get_web_list函数：获取Web列表get_pocs函数：获取POCSget_failed_pocs函数：获取失败的POCSget_vuin_statistics函数：获取漏洞统计信息get_vulnerability_search函数：获取漏洞搜索结果get_poc_info函数：获取POC信息get_ip_segment函数：获取IP段get_vulanalysis函数：获取漏洞分析结果get_asset_tags函数：获取资产标签get_env_info函数：获取环境信息set_envinfo函数：设置环境信息这些API接口涵盖了漏洞扫描、统计数据、资产搜索等多方面的操作。用户可以根据实际需求选择相应的API接口进行调用。更多详情和调用方法请访问https://www.exp-9.com/category-20.html。安装方法使用以下命令安装GOBY SDK for Python：pip install goby-sdk
Package: goc
GOCThis script,goc.py, is a utility tool that leverages the OpenAI GPT-3.5 Turbo model to generate Markdown documentation for Git diffs and commits. It can be used to automatically generate a markdown document based on the output of git diff:PrerequisitesYou will need an OpenAI API key, configure it to the environment variable like below:exportOPENAI_API_KEY=<your_key_here>You will need a python version higher than 3.8InstallationYou can either install from Pypi (https://pypi.org/project/goc/)pipinstallgocOr you can download this repository and runpoetryinstallUsageTo execute the script, run the following command:goc[mode][arguments]Replace [mode] with one of the following options:diff: Generate documentation for the git diff between commits or files.
commit: Generate a commit message for the current git diff.
Replace [arguments] based on the mode selected:For the diff mode, provide the arguments to specify the commits or files to compare.
For the commit mode, no additional arguments are needed.Generate documentation for the diff between two commits:gocdiff[commit_a][commit_b]Document Comparison vs Current Commit:gocdiff[commit_hash]Document Comparison of a single commit:gocdiff[commit_hash]^!Document Staged Changes:gocdiff--stagedAutomatically generate commit message and commit:goccommitOutputThe script generates Markdown documentation by utilizing the OpenAI GPT-3.5 Turbo model. The resulting documentation will be displayed in the console output.Examples$gocdiffa0f72101be85667a362425c2cdc30ef794e2a738## Commit Details-**CommitType:**Codeupdate
-**CommitScope:**goc.py,pyproject.toml
-**CommitDescription:**### goc.py1.Removedthe`document_comparison_vs_current_commit`and`document_comparison_of_2_commits`functionsastheywerenotbeingused.2.Createdanewfunction`document_git_diff_wrap`thattakescommandlineargumentsandrunsthe`gitdiff`commandwiththosearguments.Thisallowsforeasycomparisonofcommitsbypassingthecommithashesorbranchesdirectlyasarguments.3.Modifiedthe`goc`functiontohandledifferentscenariosbasedonthenumberofcommandlineargumentspassed.Ifnoargumentsareprovided,itcomparesthelatesttwocommits.Ifoneormoreargumentsareprovided,itpassesthemdirectlyto`document_git_diff_wrap`forcomparison.4.updatedthe`parse_gpt_resp`functiontoreturnthecontentofthelastchoice/messageintheresponse,asthefinalgeneratedmarkdowncontentisusuallythelastchoice.### pyproject.toml1.Updatedtheversionto`"0.2.0"`.

Pleasereviewandmergethesechanges.$goccommit
Committingwithmessage:"Update git diff handling, handle case when no diff is found"NoteMake sure you have the necessary permissions and access to the Git repository you intend to analyze. Also, ensure that the repository is properly cloned on your local machine.DisclaimerThis tool relies on the OpenAI GPT-3.5 Turbo model for generating documentation. The accuracy and quality of the generated content depend on the model's training data and the provided input. Please review and validate the generated documentation before using it in your projects.