Saravanan666/pypi-org huggingface dataset:
Package: gulagcleaner
Gulag CleanerGulag Cleaner is a tool designed to remove advertisements from PDFs, making it easier to read and navigate documents without being disrupted by unwanted ads.This tool does not just crop the ads out of the PDF, instead, we extract the original file without ads by manipulating the internal structure of the PDF, ensuring maximum quality.In addition to removing advertisements, Gulag Cleaner is also capable of extracting metadata, such as the author, subject, university, and more, from the file.Web VersionThis tool can be used without installation directly fromour website(in Spanish).InstallationTo install Gulag Cleaner, pleasedownloadandinstallPython and then run the following command in your terminal:pip install gulagcleanerUsageGulag Cleaner can be used through both a Command Line Interface (CLI) and in your code.Command Line InterfaceTo use Gulag Cleaner through the CLI, simply run the following command, replacing<filename>with the name of one or more PDF files or folders containing PDF:gulagcleaner [-r] [-s] [-n] [-h] [-v] <filename>...OptionsGulag Cleaner provides several options for its usage:'-r': Replace the original file with the cleaned version.'-s': Do not show metadata about cleaned files.'-n': Force the naive cleaning method.'-h': Display the help message, providing information on how to use Gulag Cleaner.'-v': Display the current version of Gulag Cleaner.CodeTo use Gulag Cleaner in your code, you can use the following code snippet:fromgulagcleaner.extractimportclean_pdfreturn_msg=clean_pdf_path("input.pdf","output.pdf")LicenseGulag Cleaner is distributed under the GPL-3 license, which means it's open-source and free to use.ContributingWe're always looking for ways to improve Gulag Cleaner, and we welcome contributions from the community. If you have ideas for improvements or bug fixes, please feel free to submit a pull request.TODOIf you want to help, these are the top priorities right now:Write tests for the package.Add README.md (With code examples) for the rust and JS distributions.Add comments to a lot of the rust code.Optimize the rust code for performance improvements.Add a new "clean_pdf_bytes()" function in python that does not require a file path, just the bytes.
Package: gulagcleaner-xv
Gulag-cleanerATENCIÓN: Desde el 27/09/22 la versión en Python de este programa ha sido descontinuada y no recibirá mas actualizaciones.Herramienta de eliminación de anuncios para PDFs generados por la plataforma Wuolah.
Es un inverso funcional de las funciones que insertan páginas pdf dentro de otros documentos en forma de objetos de tipo Form. El ejemplo más prominente es la función embedPages() de la librería PDF-lib.jsTambién es capaz de extraer los Metadatos (Autor, Asignatura, Universidad...) del archivo. Para más información consultar la descripción de la función.Instalaciónpip install gulagcleaner-xvOpciones-r : reemplaza los archivos originales-h : muestra información-v : muestra la versión actualUsoCLI:gulagcleaner <filename>Code:from gulagcleaner.gulagcleaner_extract import deembedreturn_msg = deembed( "file.pdf" , replace)
Package: gulf
gulf简体中文Descriptiongulfis an open-source integrated finance data source and database application on top ofDolphinDBandakshare.InstallationYou can install the latest stable version from pip using:pip install gulfIf you plan to develop gulf yourself, or want to be on the cutting edge, you can use an editable install:gitclonehttps://github.com/FangyangJz/gulf.git
pipinstall-e.About development environmentUsepoetryas dependency management andcondaas virtual environment management.InPyCharmsettings,poetryvenv creation may meet error, because the OS system is not native English. Socondawas used as the virtual environment management, and author usedpython3.9 version.If you follow the officialpoetrymanual and create a redundant venv, just delete it. Check the following locations (note hidden paths):C:\Users\fangy\AppData\Local\pypoetry\Cache\virtualenvsIf the virtual environment is not automatically activated, manually switch:conda activate your_venv_nameAfter activate the virtual environment,poetry update/init/install/addcommand is executed on the shell.Stack overflow link
Package: gulf-id-scanner
Read Gulf ID card dataPython package that interfaces with the Gulf ID and EID card reader service. It uses websocket to connect to the service installed on the host machine where a USB smart card reader is connected.UsageInstall the card reader service on a windows machineEnsure the services are runningGet the IP of the machineimportaiohttpfromgulf_id_scannerimportClient,ServiceErrorsession=aiohttp.ClientSession()client=Client(host="192.168.3.45",web_session=session)# validate connectiontry:awaitclient.connect()exceptServiceErroraserr:returnFalse# read card datatry:card_data=client.async_read_card():# code to process returned card dataexceptServiceErroraserr:return# detect when card is inserted and read card datatry:asyncforcard_datainclient.async_detect_card():# code to process returned card dataexceptServiceErroraserr:returnawaitsession.close()Card DataTheCardDataclass provides the main card data fields that are commonly required when reading the ID. For more specific fields you can find all the data fields retrived fromCardData.card_data.
Package: gull-api
GULL-APIGULL-API is a web application backend that can be used to run Large Language Models (LLMs). The interface between the front-end and the back-end is a JSON REST API.FeaturesExposes a/apiroute that returns a JSON file describing the parameters of the LLM.Provides a/llmroute that accepts POST requests with JSON payloads to run the LLM with the specified parameters.InstallationUsing DockerBuild the Docker image:docker build -t gull-api .Run the Docker container:docker run -p 8000:8000 gull-apiThe API will be available athttp://localhost:8000.Docker Test ModeTo build and run the Docker container in test mode, use the following commands:dockerbuild-tgull-api.
dockerrun-v$(pwd)/data:/app/data-v$(pwd)/example_cli.json:/app/cli.json-p8000:8000gull-apiIn test mode, an included script echo_args.sh is used instead of a real LLM. This script echoes the arguments it receives, which can be helpful for local testing.Local InstallationClone the repository:git clone https://github.com/yourusername/gull-api.gitChange to the project directory:cd gull-apiInstall the dependencies:pip install poetry
poetry installConfigure Environment Variables (Optional):GULL-APIcan be configured using environment variables. To do this, create a file named.envin the root of the project directory, and set the environment variables there. For example:DB_URI=sqlite:///mydatabase.db
CLI_JSON_PATH=/path/to/cli.jsonGULL-APIuses thepython-dotenvpackage to load these environment variables when the application starts.Run the application:uvicorn gull_api.main:app --host 0.0.0.0 --port 8000The API will be available athttp://localhost:8000.Usage/apiRouteSend a GET request to the/apiroute to retrieve a JSON file describing the parameters of the LLM:GET http://localhost:8000/api/llmRouteSend a POST request to the/llmroute with a JSON payload containing the LLM parameters:POST http://localhost:8000/llm
Content-Type: application/json

{
  "Prompt": "Once upon a time",
  "Top P": 0.5
}Example Requestscurl-XPOST"http://localhost:8000/llm"-H"accept: application/json"-H"Content-Type: application/json"-d"{\"Instruct mode\":false, \"Maximum length\":256, \"Prompt\":\"Hello, world\", \"Stop sequences\":\"Goodbye, world\", \"Temperature\":0.7, \"Top P\":0.95}"curl-XGET"http://localhost:8000/api"-H"accept: application/json"|python-mjson.toolExample CLI JSONAn example CLI JSON file is provided in the repository asexample_cli.json. This file provides an example of the expected structure for defining the command-line arguments for the LLM.LicenseSee LICENSE
Package: gullikson-scripts
Kevin Gullikson’s ScriptsThis is a variety of packages that I use in my research. This package was made as a convenience to anyone interested in my work, and is not very thoroughly tested. The repository that I have been using the last several years in locatedhere, but is much more of a pain to install…InstallationIf you use anaconda python, use:condainstallh5pypandasscipymatplotlibbokeh==0.10astropyscikit-learncythonseabornpytablespythonsetup.pyinstall
Package: gullveig
GullveigGullveig is a free, open-source, light-weight infrastructure and service monitoring and operations support platform.
Gullveig offers monitoring, alerting, and insights services for servers, services and applications, as well
as other useful administrator and operations features.Gullveig is modular and flexible, and allows for easy development of custom monitoring and reporting modules
that can be created using nearly any platform or programming language.Documentation is available atgullveig.hub256.com.Core featuresDistributed and scalable agent based monitoring architecture.Modern, easy to use web interface.Time series graphs for resources, counters, metrics and performance data.Double-redundant bi-directional remote monitoring.Automated alerting and notifications about status changes.Rich interface for remote fact and metadata discovery.Interactive status dashboard.Simple, file based configuration.Wide operating system support (written in Python 3).Does not depend on third party software for basic operation.Built in static documentation server.Current statusGullveig is actively developed and maintained, and is stable enough for production use - it is already used as primary
or as an additional monitoring tool in production deployments, sizes ranging from a handful to a few hundreds of nodes.All updates and new releases are subject to thecompatibility policy.LicenseLicensed under terms and conditions of Apache 2.0 license.
Package: gulpio2
Binary storage format for deep learning on videos.Fork noticeThis is a fork of TwentyBN’sgulpio.
Key differences:faster: Usessimplejpegfor JPEG decoding by default (a wrapper around
libjpeg-turbo) and replaces OpenCV with Pillow-SIMD for resizing images.more flexible: More frame access patterns are supported, not onlysliceaccesses.Installationpip install gulpio2Migrating from gulpioIf you’ve been usinggulpio, then you can usegulpio2as a drop-in replacement. Simply replace allimport gulpio ...statements withimport gulpio2 ....Prior ArtInspired by: MXNet based RecordIO:http://mxnet.io/architecture/note_data_loading.htmlGulpIO: Original codebasehttps://github.com/TwentyBN/GulpIOLicenseAll original gulpio code is Copyright (c) Twenty Billion Neurons and
licensed under the MIT License, see the fileLICENSE.txtfor details.
Subsequent code is Copyright (c) Will Price, and is also licensed under the MIT
License.
Package: gum
GUM (Group, User Manager)GUM allows you to manage user accounts and groups stored in an LDAP server.
It provides a user-friendly web interface for managing those users and
groups. It also has a plug-in system to allow Python extensions to be
called when modifications are made to LDAP entries.GUM is written in Python using the Grok web framework.InstallationGUM is intended to be installed using Buildout. It requires Python 2.6.$ python2.6 bootstrap/bootstrap.py
$ ./bin/buildoutFrom here you can start a development LDAP server with:$ ./bin/slapd startThen start the web server with:$ ./bin/zopectl startThis will start the server on port 8080.More likely than not though, you want to install a version to use in
production. In this case, copy the ‘buildout.cfg’ file and name it
‘production.cfg’. Then edit this file with production configuration,
and install it with:$ ./bin/buildout -c production.cfgBut the buildout config is still a bit murky at the moment, as well
as the post-installation experience – if you are trying to install this
and get stuck, please contact the author by email.DevelopTo develop GUM you should have an LDAP instance for developing with.
You must have OpenLDAP pre-installed (currently this works on Mac OS X,
will need tweaking for other OSes). You must start this instance before
running the app or functional tests:$ ./bin/slapd startIf you need to debug LDAP, it can be started in debug mode with:$ /usr/libexec/slapd -f ./parts/slapd/slapd.conf -d 255-hldap://127.0.0.1:1700Note that the functional tests expect the server to start on port 1700.Changelog for GUM0.8.1 (2009-03-20)Basic setup.py metadata and README.txt added.0.8 (2009-03-20)Start of the history.
Package: gumbi
Gumbi: Gaussian Process Model Building InterfaceOverviewGumbi simplifies the steps needed to build a Gaussian Process model from tabular data. It takes care of shaping,
transforming, and standardizing data as necessary while applying best practices and sensible defaults to the
construction of the GP model itself. Taking inspiration from popular packages such asBambiandSeaborn,
Gumbi's aim is to allow quick iteration on both model structure and prediction visualization. Gumbi is primarily built
on top ofPymc, though additional support forGPflowis planned.QuickstartRead in some data and store it as a GumbiDataSet:importgumbiasgmbimportseabornassnscars=sns.load_dataset('mpg').dropna()ds=gmb.DataSet(cars,outputs=['mpg','acceleration'],log_vars=['mpg','acceleration','weight','horsepower','displacement'])Create a GumbiGPobject and fit a model that predictsmpgfromhorsepower:gp=gmb.GP(ds)gp.fit(outputs=['mpg'],continuous_dims=['horsepower']);Make predictions and plot!X=gp.prepare_grid()y=gp.predict_grid()gmb.ParrayPlotter(X,y).plot()More complex GPs are also possible, such as correlated multi-input and multi-output systems. See the docs for more examples.InstallationVia pippip install gumbiBleeding edgepip install git+git://github.com/JohnGoertz/Gumbi.git@developLocal developmenstClone the repo and navigate to the new directorygit clone https://gitlab.com/JohnGoertz/gumbi gumbicd gumbiCreate a new conda environment using mambaconda install mambamamba install -f dev_environment.yamlInstallgumbiviapipin editable/development modeFrom within thegumbirepopip install --editable ./To update thegumbimoduleFrom within thegumbirepogit pull
Package: gumd
"I've been googling for some time now, and still have yet to find a working example of Python multicast"Behold gumd.GrandeUnicastMulticastDaemonLatest isv.0.0.17Installpython3-mpipinstallgumdUse gumd (Daemon) programmatically>>>>fromgumdimportGumD>>>>gumd=GumD('235.35.3.5:3535',ttl=1)>>>>gumd.send_stream("/home/a/stuff")streamuri:udp://@235.35.3.5:3535>>>>Use gumc (Client) programmatically>>>>fromgumcimportGumC>>>>gumc=GumC("udp://@235.35.3.5:3535")>>>>data=gumc.read(8)>>>>datab'Helloooo'Cli toolsThe cli toolsgumd and gumctry to install to ~/.local/binmake sure ~/.local/bin is in your path I have this at the end my .bashrcPLAN9=/home/a/plan9portexportPLAN9PATH=/home/a/.local/bin:$PLAN9:$PATHexportPATHif you dont get them installed, roll your own.gumd(Daemon)#!/usr/bin/envpython3fromgumdimportclicli()gumc(Client)#!/usr/bin/envpython3fromgumcimportclicli()Install cli toolsinstall gumd /usr/local/bin  # or ~/.local/bin
install gumc /usr/local/bin  # or ~/.local/binUse gumd (Daemon) cliSupported input mpegts URIs:filesgumd -i /home/me/vid.tshttp(s)gumd -i https://futzu.com/xaa.tsudpgumd -i udp://127.0.0.1:4000multicastgumd -i udp://@235.1.2.3:4567reading from stdincat myvideo.ts | gumdusage:gumd[-h] [-iINPUT] [-aADDR] [-u] [-bBIND_ADDR] [-tTTL] [-v]optionalarguments:-h,--helpshowthishelpmessageandexit-iINPUT,--inputINPUTlike"/home/a/vid.ts"or"udp://@235.35.3.5:3535"or"https://futzu.com/xaa.ts"-aADDR,--addrADDRDestinationAddress:Portlike"227.1.3.10:4310"-u,--unicastUseUnicastinsteadofMulticast-bBIND_ADDR,--bind_addrBIND_ADDRLocalIPandPorttobindtolike"192.168.1.34:5555".Defaultis"0.0.0.0:1025"-tTTL,--ttlTTLMulticastTTL1-255-v,--versionShowversionstart gumd (Daemon) clia@debian:~/gumd$gumd-i/home/a/abc.pystreamuri:udp://@235.35.3.5:3535a@debian:~/gumd$use gumc (Client) cliusage:gumc[-h][-iINSTUFF][-bBYTESIZE][-v]options:-h,--help            show this help message and exit-iINSTUFF,--instuff INSTUFFdefaultis'udp://@235.35.3.5:3535'-bBYTESIZE,--bytesize BYTESIZENumberofbytestoread.defaultis1-v,--version         Show versionstart gumc (Client) clia@debian:~/build/clean/gumd$gumc-iudp://@235.35.3.5:3535-b1024Test gumd and gumc togetherfirst terminal, start the client,gumca@debian:~/build/clean/gumd$pypy3gumc.py-b5-iudp://@235.35.3.5:3535second terminal,start the daemon, gumd__ and send a "hello"a@debian:~/build/clean/gumd$printf'hello'|gumd-a235.35.3.5:3535streamuri:udp://@235.35.3.5:3535play gumd (Daemon) stream with ffplayffplayudp://@235.35.3.5:3535segment stream from gumd  (Daemon) into hls withx9k3pypy3x9k3.py-iudp://@235.35.3.5:3535read 13 bytes from a multicast stream with gumc (Client)gumc-iudp://@235.35.3.5:3535-b13read 10000 bytes from a multicast stream with gumc (Client)gumc-iudp://@235.35.3.5:3535-b10000Note: a multicast client works a little differently than most people expect.You must specify a size to read or the client will never return..Phase One: Expose the Pep Deep State* [Phase One has begun](https://github.com/python/peps/compare/main...futzu:peps:main)
Package: gumiyabot
Standalone Twitch + Bancho IRC bot for handling osu! beatmap requests.This package is used inGumiyaand is provided for users that wish to run their own bot instance and customize the bot’s functionality.
If you only want a beatmap request bot, but do not need to modify or customize it, you may wish to just use stockGumiyainstead.License:MITFeaturesSupport for linking a single twitch channel and single osu! accountBeatmap requestsPP info for beatmap requests (requires a Tillerino API key)RequirementsPython 3.7+Twitch IRCOAuth token - note that if you are using the token for your own Twitch account, the bot will connect to Twitch chat using your own account.
It is recommended to register a secondary Twitch account for the bot.Bancho (osu!) IRCcredentials - note that multiaccounting in osu! is forbidden, and a bannable offense.
This includes registering a bot-specific osu! account without explicit permission from osu! staff.
Therefore, it is recommended to run the bot under your own osu! account.
This will not affect any functionality, you will just receive map requests as in game PMs from yourself.osu! APIkeyInstallationVia pippip install gumiyabotAlternatively, you can clone the source repository and run the bot module directlypip install -r requirements.txt
python -m gumiyabotRunning the botGenerate a new config.inigumiyabot --new-configEdit config.ini as needed (see configuration section below)Run the botgumiyabot config.iniConfigurationSeeconfig.ini.examplefor details on configuration options.Twitch usageMap requests can be linked in the format<beatmap or mapset URL> +HDDT.
The bot accepts beatmap and mapset URLs from both the old and new osu! web sites.
PP information is dependent on Tillerino.
When mods are used, the bot output will always the display the modified AR, OD and BPM, but displaying modified star rating is dependent on Tillerino.
If Tillerino is unavailable, or if Tillerino does not have a calculated PP and difficulty for a certain map + mod combination, the nomod star rating will be used.Player stats can be queried with!stats <player name>DevelopingIf you need to extend either of the base plugin classes, there are some things to note beforehand:Your subclass must have an__init__method.
If you do not need to add any custom functionality, it should just callsuper(MyPluginClass,self).__init__().Anyirc3.eventorirc3.commanddecorated method from the base plugin class must be overridden in your subclass.
If you want the base plugin’s event or command handling, just callsuper()from your subclass.For examples, see theGumiya IRC plugins
Package: gumly
GumlyGAVB Utilities for Machine Learning YumThe library consists of a collection of methods that can be used in order to help Data Scientists and Machine Learning Engineers during the development of Machine Learning applications seeking to reduce the time spent and complexity of coding.Library Motivation and DescriptionDuring the development of ML projects at GAVB, Data Scientists have the necessity to code some features for projects repeatedly. So, MLOps area identified the opportunity to create some standard functions that can help as it can be used many times by data science area in each different project.
Thus, it is possible to work with this framework that brings basically two main advantages:
1 - Projects executed in less time than usual, due to the code reusability;
2 - Establishment of a standard coding structure for projects.FunctionalityValue ValidationDimensionality ReductionFeature EngineeringFilesHyperparameter TuningMetricsGeo LocationImbalancedCheck Point FlowHow to installpip install gumlyRelease NotesCheck theCHANGELOGfile to keep track the release features.
Package: gummi
gummiDo you have a bunch of preamble files for your LaTeX documents and you reuse them all the time? What happens when you want to update these templates? You'll need to modify all the files in all your documents! Very time-consuming work, very boring, but thankfully,very easy to automate!Withgummiyou can do just that! You just create a git repository with your template files in it and you can use them in every LaTeX document you have!Table of ContentsInstallCommandsExample:Create template,Use template,Update templateInstallSimply runpip3installgummiCommandsinit      Initializes a LaTeX document
check     Checks if any updates to the update are available
detach    Deletes all the template files
update    Updates the templates

You can use -h on any command to get help for this particular command.ExampleA LaTeX document of yours might usually look like this:- .gitignore
- main.tex
- Makefile
- sections/
|      - section1.tex
|      - section2.tex
|      - section2.tex
- templates/
|      - logo/
|      |       logo.pdf
|      - preamle.tex
|      - header.tex
|      - footer.texTypically only themain.texandsectionschange, the rest should be consistent over all your documents. Here is wheregummicommes into play!Create TemplatesFirst, create an empty folder and open a terminal window in it. Then rungummiinit--templateBasically, not much happended but agummifolder was created. Now, put all your template files into it as if the gummi folder was your root directory, like so:- gummi/
|      - .gitignore
|      - Makefile
|      - templates/
|      |      - logo/
|      |      |       logo.pdf
|      |      - preamle.tex
|      |      - header.tex
|      |      - footer.texPush that stuff to the git service you prefer.Use the TemplateNow, visit your LaTeX document folder and again, open a terminal inside it. The structure of your document looks probably like this:- main.tex
- sections/
|      - section1.tex
|      - section2.tex
|      - section2.texTime to bring up the magic! RungummiinitWhen asked for the git repository, enter the HTTPS clone URL of the repository and press enter. And this is how your document looks like afterwards:- .gitignore
- .gummi/...
- main.tex
- Makefile
- sections/
|      - section1.tex
|      - section2.tex
|      - section2.tex
- templates/
|      - logo/
|      |       logo.pdf
|      - preamle.tex
|      - header.tex
|      - footer.texUpdate the TemplateIf your want to update your templates, for example remove the Makefile and add another one, do just that in your template repository and push the changes to the remote git server. Then, simply rungummiupdatein your LaTeX document. Your changes are applied immediately! Any changes made locally to a template file will not be lost, these files do not get updated.The.gummifolder is important, it is responsible for tracking changes to your templates.Move the binary to a place where your$PATHpoints to or extend the variable.