Saravanan666/pypi-org huggingface dataset:
Package: glfw-toolbox
Source repo ongithubIntroductionglfwToolbox that contains several functions to init OpenGL, create models,
load textures, create vectors, load OBJ, GEMH files, etc.Install Instructionsglfw-Toolbox can be downloaded via pip. Simply run pip install
glfw-toolbox.DependenciesThis library is dependant on the followingnumpyPyOpenGLglfwPILmatplotlibContributorsIdeas and contributions are always welcome. Any found bugs or
enhancement suggestions should be posted in the issues tab.Aditional InformationLicensingThis project is distributed using the MIT license.For more licensing information read LICENSE on github.Contact Info:This project does not have a mailing list and so the issues tab should
be the first point of contact if wishing to discuss the project. If you
have questions that you do not feel are relavent to the issues tab or
just want to let me know what you think about the library, feel free to
email me.Email:pablo@ppizarror.com
Package: gl-ggui
GGUIGGUI is a graphical user interface for pygame with opengl.Its a thin wrapper around these libs to provide basic tools to rende text, scrollable windows, buttons and dropdowns inside your pygame application.It supports images, borders, antialiased text and text outlines, styles and style changes on hover and on click, transparency, toggles such as hide/show enable/disable, and uses lazy rendering for increased text rendering performance.It also supports event-driven programming by firing click and select events through pypubsub.UsageBasic usage is shown through example.pyMore complete and advanced usage is showcased in a simple game, idle_game.py.
Package: glglue
glglueThe glue code which mediates between OpenGL and some GUI.
GUI イベント(resize, mouse, keyboard, repaint) を OpenGL に橋渡しする。GUI                         OpenGL controller
+--------+                   +------------+
| win32  |--window resize--->| Update     |
| glut   |--mouse input----->| Update     |
| sdl    |--keyboard input-->| Update     |
| pyside6|                   |            |
| gtk3   |--repaint--------->| Draw       |
| gtk4   |                   +------------+
+--------+And OpenGL utilities.RequirementsPython 3.10Sitehttps://ousttrue.github.io/glglue/https://pypi.python.org/pypi/glglue/
Package: glhooks
This is simple server (receiver) forGitLab’swebhooks feature.Alternativeshttps://github.com/shawn-sterling/gitlab-webhook-receiverhttps://github.com/vinodc/gitlab-webhook-branch-deployerInstallationMake sure you havePython2.6+/3.2+ properly installed (Windows/Linux). Then just type[sudo] pip install glhooksin your favorite shell. Now you haveglhooksinstalled so you can run it like thispython-mglhooks<path_to_config_file>.... You can find skeleton for the configuration file ingit repositoryinconfig/config.ini.I recommendSupervisoror similar application to run theglhooksserver. Install it via[sudo]apt-getinstall supervisor. You can find the example ofSupervisorconfiguration file forglhooksingit repositoryinconfig/glhooks.conf. But you can just create some shell script and copy it into/etc/init.d/(example ingit repositoryinconfig/glhooks.sh).Next step is to generate a SSH keywithout the passphrase:ssh-keygen-b4096-trsa. Then add the generated SSHpublic keyto your GitLab account. If you have multiple SSH keys in$HOME/.ssh/you probably has to create file$HOME/.ssh/config. You can find the example file ingit repositoryinconfig/config.ssh.Finally add the hookhttp://server.example.com:8000/into your project webhooks at GitLab.UpdatingWhen you change at least one of the configuration files you has to restartglhooksserver by[sudo] supervisorctl restart glhooksor[sudo] service glhooks restart.ContributingFeel free tosend a pull requestor toreport an issue.Changelog0.1.0 (2014-01-14)First public release.
Package: gli4py
gli4pyA aysnc python 3 API wrapper for GL-inet routers with version 4 firmware. [WIP]GL-inetrouters are built onOpenWRT. They are highly customizeable but have an attractive user interface.As part of their modiification of the UI they provide alocally accessible API.I thought it would be handy to develop a python 3 wrapper for the API for easy intergation into other services such asHomeAssistantInstallationpip3 install gli-pyDev setupClone the repoEnsure you have python 3 installedpython3 -Vorpython -VUses poetry for venv controlpip3 install poetrypoetry config virtualenvs.in-project truecreate the venvs in the project folderpoetry installpoetry shellTo run tests, ensure there is a file calledrouter_pwdin the root directory with the router password in.Then runpytest -sto see responses, assumes the router is at192.168.0.1Set token withpoetry config pypi-token.pypi TOKENpublish withpoetry publishTodo list:Decide on useful endpoints to expose - seehttps://github.com/HarvsG/ha-glinet-integration#todoExpose said endpointsWrite remainingPackage correctlyTest that dev enviroment is re-producablePublish on pipStatic typing
Package: gli99
Do NOT use this repo for professional use. This was a personal project to practice version control, web scraping, and readme design. The correct way to access GifCities.org is through its (admittedly slow)API.InstallationRun the following to install:pipinstallgli99Usagefromgli99.toolsimportGifScrapergs=GifScraper(browser="firefox")gs.load(query="brazil",amount=5)gs.download()currently supported browsers:EdgeChromeFirefox
Package: gliaml
# GliaMLGliaML is simple, yet powerful machine learning library written in Python.Currently, it allows a user to easily create a multi-layer perceptron neural network with
the following features:Allow backpropagation with the sigmoid, tanh, and ReLU activation functions.Allow normalisation of a classifier with the softmax function.Allow learning rate hyperparameter functionality (including biases)Allow L2 regularisation to prevent over-fitting## Creating a NetworkIn GliaML, neural networks are implemented as objects containing a collection of layers,
which are in turn objects. To create a layer, first a list of activation functions for
each neuron in the list must be chosen. Then the layer can be created. Bias functionality
can beactivations1 = [activation_id for i in range(0, num_neurons)]
layer1 = NetworkLayer(num_inputs, num_neurons, activations1, bias=False)After a satisfactory number of layers have been created, the neural network itself can be
invoked by calling the constructor and providing all the layers. Ifnetwork = NeuralNetwork(l2_regularization=0.03, layer1, layer2, …)## Training a networkAfter creating your network, you’ll want to provide training and testing data. These should
be formatted as NumPy arrays. For example, let us consider the following training set.training_inputs = np.array([[1, 0, 1], [0, 0, 1], [1, 1, 0], [0, 1, 0]])
training_outputs = np.array([[1, 1, 0, 0]]).TThe solution is whether or not there is a 1 or 0 in the 3rd place of the input array. We now
need to train the network. We can either use mean-squared error or cross-entropy loss.network.train_mean_squared_error(training_inputs, training_outputs, num_iterations,learning_rate=0.05, bias_learning_rate=0.05)We can now see the network’s response on a problem it hasn’t seen before.answer = network.think(np.array([1, 1, 1]))
print(answer[-1])See [example.py](https://github.com/Archiecool4/GliaML/blob/master/example.py) for another
usage example.
Package: glib-log-bridge
Python ↔ GLib logger bridgeThis library allows you to redirect either from thepython logger facilityto theglib logging facility, or the other way around.NOTE: THIS IS STILL IN DEVELOPMENT! IT MIGHT NOT WORK CORRECTLY, AND THE INTERFACE CAN CHANGE!Quick UsageGLib → Pythonfromgi.repositoryimportGLibimportglib_log_bridge.glib2pythonasglib2pythong2plog=glib2python.GLibToPythonLogger()GLib.log_set_writer_func(g2plog.glibToPythonLogWriterFunc,None)Python → GLibimportloggingimportglib_log_bridge.python2glibaspython2glibhandler=python2glib.PythonToGLibLoggerHandler()logging.getLogger().addHandler(handler)# Logger to apply, logger.getLogger() does it for all messages
Package: glide-client
Glide Python Client🐍 An official Python client forGlide, an open reliable fast model gateway.[!Warning]
Glide is under active development right now 🛠️[!Important]
Give us a star⭐ to support the project and watch👀 our repositories not to miss any updateFeatures🐍Modern typed Python withPydantic-baseddata classesSync and asyncio supportInstallationComing soonUsageComing soon
Package: glidergun
glidergunpip install glidergunOverviewcreation / iogridstacksaveoperatorsmost overloadable Python operatorspropertieswidthheightdtypexminyminxmaxymaxextentmeanstdminmaxcell_sizemd5locallocal (higher order)is_nanabssincostanarcsinarccosarctanlogroundgaussian_filtergaussian_gradient_magnitudegaussian_laplaceprewittsobeluniform_filteruniform_filter1dfocalfocal (higher order)focal_meanfocal_stdfocal_varfocal_medianfocal_minfocal_maxfocal_sumfocal_ptpfocal_percentilefocal_quantilefocal_entropyfocal_hmeanfocal_pmeanfocal_kurtosisfocal_iqrfocal_modefocal_momentfocal_skewfocal_kstatfocal_kstatvarfocal_tmeanfocal_tvarfocal_tminfocal_tmaxfocal_tstdfocal_variationfocal_median_abs_deviationfocal_chisquarefocal_ttest_indzonalzonal (higher order)zonal_meanzonal_stdzonal_varzonal_medianzonal_minzonal_maxzonal_sumzonal_ptpzonal_percentilezonal_quantilezonal_entropyzonal_hmeanzonal_pmeanzonal_kurtosiszonal_iqrzonal_modezonal_momentzonal_skewzonal_kstatzonal_kstatvarzonal_tmeanzonal_tvarzonal_tminzonal_tmaxzonal_tstdzonal_variationzonal_median_abs_deviationinterpolationinterpolate (higher order)interp_linearinterp_nearestinterp_rbfregression / classificationfit (higher order)fit_linear_regressionfit_decision_tree_classificationfit_decision_tree_regressionfit_mlp_classificationfit_mlp_regressionfit_random_forest_classificationfit_random_forest_regressionsurfaceaspectslopehillshadeconversion, etc.clipconfill_nanfrom_polygonsmosaicpcaprojectrandomizereclassreplaceresamplescaleset_nanshrinkstandardizeto_pointsto_polygonsto_stackipythonplot (Matplotlib)map (Folium)
Package: gliderpy
gliderpyGliderpy aims to facilitate effortless access to glider data hosted on ERDDAP servers.
Gliderpy is a high level wrapper arounderddapy,
with glider specific tooling and in-built plotting methods.Try it out on binderAnd check the docs for more info:https://ioos.github.io/gliderpyInstallationForcondausers you cancondainstall--channelconda-forgegliderpyor, if you are apipuserspipinstallgliderpy
Package: glidertools
Glider tools is a Python 3.8+ package designed to process data from the first level of processing to a science ready dataset (delayed mode quality control). The package is designed to easily import data to a standard column format (numpy.ndarray or pandas.DataFrame). Cleaning and smoothing functions are flexible and can be applied as required by the user. We provide examples and demonstrate best practices as developed by theSOCCO Group, with early contributions fromPolar Glidersat the University of Gothenburg. GliderTools includes contributions fromVOTO. We aim to implement Best Practices developed byOceanGlidersin the ongoingdiscussions.Please cite theoriginal publicationof this package andthe package itself.InstallationCondaTo install the core package from conda-forge run:conda install-cconda-forgeglidertoolsPyPITo install the core package run:pip install glidertools.GitHubClone glidertools to your local machine:git clonehttps://github.com/GliderToolsCommunity/GliderToolsChange to the parent directory of GliderToolsInstall glidertools withpip install-e./GliderTools. This will allow
changes you make locally, to be reflected when you import the package in PythonRecommended, but optional packagesThere are some packages that are not installed by default, as these are large packages or can
result in installation errors, resulting in failure to install GliderTools.
These should install automatically withpip install package_name:gsw: accurate density calculation (may fail in some cases)pykrige: variogram plotting (installation generally works, except when bundled)plotly: interactive 3D plots (large package)How you can contributeJoin the communityby introducing yourself(no need to be a Python or Git guru! Just say what you are working with and join the discussion)If you find an error, please report it onas a Github issue. Please copy the entire error message (even if it’s long).Oxygen processing is rudimentary so far but we are on it and happy to get your supportin this discussionFor contributing follow theinstructionsAcknowledgementsWe rely heavily onion_functions.data.flo_functionswhich was
written by Christopher Wingard, Craig Risien, Russell DesiderioThis work was initially funded by Pedro M Scheel Monteiro at the
Council for Scientific and Industrial Research (where Luke was working
at the time of writing the code).Testers for their feedback: SOCCO team at the CSIR and …
Package: glim
DocumentationRoadmapChangelogglim is a modern web framework on top ofbottleinspired fromplay&laravel. The aim is to build a lightweight architecture for web app development. The development philosophy here is to make the core small as possible but still not featureless. It has a conventional extension system that can boot objects with configuration. It also has a handful set of extensions for view rendering, templating and performing database operations. You can checkglim_extensionsrepository for much more information.FeaturesConvention over configurationA powerful routing system which has grouping & filteringA controller layer for request handling, service calling, etc.A set of handful extensions that includes SQLAlchemy, Jinja2, redis, etc. integrationsAn object oriented command line layerAn extension system that developers can integrate to the frameworkQuick Start# create project folder
$ mkdir <project>
$ cd <project>

# create a virtualenv
$ virtualenv venv

# activate the virtualenv
$ . venv/bin/activate

# install glim from pypi
$ pip install glim

# generate a new glim app
$ glim new

# start the web server
$ glim startCutting edge# clone the repo inside the project folder
$ git clone git@github.com:aacanakin/glim.git

# enter the folder
$ cd glim

# create & virtualenv
$ virtualenv venv
$ . venv/bin/activate

# install dependencies
$ pip install -r requirements.txt

# generate a new app
$ python glim.py new

# run the web server
$ python glim.py startglim issmall & lightweightgreat for painless web app developmentgreat for api/web-service developmentglim isn’tdjangoflaskstable currently :(NOTE: The framework is in its early stages in development. So, there are lots of backward incompatible changes constantly. So the web server may not even start but feel free to play with it!
Package: glimix-core
glimix-coreFast inference over mean and covariance parameters for Generalised Linear Mixed
Models.It implements the mathematical tricks ofFaST-LMMfor the special case
of Linear Mixed Models with a linear covariance matrix and provides an
interface to perform inference over millions of covariates in seconds.
The Generalised Linear Mixed Model inference is implemented via Expectation
Propagation and also makes use of several mathematical tricks to handle large
data sets with thousands of samples and millions of covariates.InstallThere are two main ways of installing it.
Viapip:pipinstallglimix-coreOr viaconda:condainstall-cconda-forgeglimix-coreRunning the testsAfter installation, you can test itpython-c"import glimix_core; glimix_core.test()"as long as you havepytest.UsageHere it is a very simple example to get you started:>>>fromnumpyimportarray,ones>>>fromnumpy_sugar.linalgimporteconomic_qs_linear>>>fromglimix_core.lmmimportLMM>>>>>>X=array([[1,2],[3,-1],[1.1,0.5],[0.5,-0.4]],float)>>>QS=economic_qs_linear(X,False)>>>X=ones((4,1))>>>y=array([-1,2,0.3,0.5])>>>lmm=LMM(y,X,QS)>>>lmm.fit(verbose=False)>>>lmm.lml()-2.2726234086180557We  also provide an extensivedocumentationabout the library.AuthorsDanilo HortaLicenseThis project is licensed under theMIT License.
Package: glimlach
Glimlach is a cybersecurity automation tool designed to streamline the execution of multiple open-source security tools in a single scan. The project is initiated to support Rauli’s research, enabling automated complex security scans with commonly used tools like Nmap, Testssl.sh, and Ssh-audit. This tool is a Python script that allows you to run Docker tools in parallel based on a JSON configuration file. It is designed to make it easy to automate the execution of Docker images with customizable parameters.The primary objective is to facilitate the execution of various cybersecurity tools as a single scan without the need for individual installations and configurations. Glimlach focuses on the containerized execution (OCI) of tools, allowing for isolation and reproducibility.
Package: glimmr
Python Glimmr API ClientAn asynchronous Python client for Glimmr.AboutThis package allows you to control and monitor a Glimmr device
programmatically. It is mainly created to allow third-party programs to automate
the behavior of Glimmr.InstallationpipinstallglimmrUsageimportasynciofromglimmrimportGlimmrasyncdefmain():"""Show example on controlling your GLIMMR device."""asyncwithGlimmr("glimmr-333.local")asled:# Fetch dataawaitled.update()print(led.system_data)# Add callback for data from web socketled.socket.on("olo",data_updated)# Set device to video modeawaitled.set_mode(1)awaitasyncio.sleep(1000)# Ambient colorawaitled.set_ambient_color("FF00FF")awaitasyncio.sleep(1000)# Ambient sceneawaitled.set_ambient_scene(4)awaitasyncio.sleep(1000)# Set device to "off"awaitled.set_mode(0)defdata_updated(self,data):print("Websocket callback: ",data)if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())ContributingThis is an active open-source project. We are always open to people who want to
use the code or contribute to it.
Package: glimpse
The Glimpse project[IJCNN2013]is a library for implementing hierarchical
visual models in C++ and Python. The goal of this project is to allow a
broad range of feed-forward, hierarchical models to be encoded in a
high-level declarative manner, with low-level details of the implementation
hidden from view. This project combines an efficient implementation with the
ability to leverage parallel processing facilities and is designed to run on
multiple operating systems using only common, freely-available components. A
prototype of Glimpse has been used to encode an HMAX-like model, achieving
results comparable with those found in the literature. The project has been
supported by NSF Grant 1018967 (PIs: Melanie Mitchell and Garrett Kenyon).Sourcecodeanddocumentationare available for the project, as well as an
installablepackage.[IJCNN2013]Michael D. Thomure, Melanie Mitchell, Garrett T. Kenyon
(2013). On the Role of Shape Prototypes in Hierarchical Models of Vision.
To appear inThe International Joint Conference on Neural Networks
(IJCNN).
Package: glin
Manages animations for LED stripesAboutglin manages und runs your animations for LED stripes like WS2801, WS2811 and similar.glin is fully implemented in Python. It uses ZeroMQ as frontend, so it’s possible to use nearly every platform to build graphical or command line interfaces to interact with glin.glin is in active development. Consider it as unstable!features:fully controllable via ZeroMQvariable FPS, depending on animation and LED stripe capabilitiesmultiple ZeroMQ clients can be connected at the same timetalk to LED Strip via UDPsome sample animations (Static Color and Nova)automatically detect and load supported animationspartial implemented:use configuration files for server side configurationload various backends for communicating with LED stripe (UDP, SPI,…)planned features:SPI backend, esp. for Raspberry Pimore animationsdependencies:Python 3 (Python 2 is not supported)ZeroMQ (pyzmq)NumpysetuptoolsSetupinstallusing git:clone this repositorycd into the project folderrunsudo pip install .orsudo pip install-e.using PyPI:sudo pip install glinrun withglinParameters-c,--config: specify configuration file. A example configuration file is included (example.conf)-h,--help: show helpLicenselicensed under LGPL v3.0 (see LICENSE file)
Package: glink2
glinkSync files between gist and localhost.PurposeWhen I clone a lot of repos and found a lot of interesting code file,
I can simplily push them to my gist viaglink.After I pull all the above repos,
I can simplily update all my gists via one single command (glink sync).glinkstore sync states in~/.config/Cologler/glink/...,
which mean if you move the linked file,
it will lose the connection.Trygist-syncif you need move the gist files.Installationpipinstallglink2LoginTo login a remote repo, you need to edit the~/.config/Cologler/glink/auth.json.
The format is like:{"<USER>@<SERVICE>":...}The user name is required because theglinksupport multi-accounts per provider.GistLogin is required for push only.To login gist, you need to create a new dev token fromhttps://github.com/settings/tokens/new.
Ensure you checked thegistscope.After you get the token, add following text intoauth.json:{"<USER>@gist":"<TOKEN>"}
Package: gli-py
gli_pyA aysnc python 3 API wrapper for GL-inet routers. [WIP]GL-inetrouters are built onOpenWRT. They are highly customizeable but have an attractive user interface.As part of their modiification of the UI they provide alocally accessible API.I thought it would be handy to develop a python 3 wrapper for the API for easy intergation into other services such asHomeAssistantInstallationpip3 install gli-pyDev setupClone the repoEnsure you have python 3 installedpython3 -Vorpython -VUses poetry for venv controlpip3 install poetrypoetry config virtualenvs.in-project truecreate the venvs in the project folderpoetry installpoetry shellTo run tests, ensure there is a file calledrouter_pwdin the root directory with the router password in.Then runpytest -sto see responses, assumes the router is at192.168.0.1Set token withpoetry config pypi-token.pypi TOKENpublish withpoetry publishTodo list:Decide on useful endpoints to expose - seehttps://github.com/HarvsG/ha-glinet-integration#todoExpose said endpointsWrite remainingPackage correctlyTest that dev enviroment is re-producablePublish on pipStatic typing
Package: glisten
GlistenSimple python logging library - because I write this code in every project.Usageimport glisten

log = glisten.log.Logger('.log')

log.warn('A warning message')produces:>>> A warning message.You can setverboseto False to suppress terminal messages (though it will always log to disk):import glisten

log = glisten.log.Logger('.log', verbose=False)

log.warn('Terminal can\'t see this')```

will produce no terminal output, but `.log` will contain `[Warning] Terminal can't see this`.

Newlines get nicely formatted:import glistenlog = glisten.log.Logger('.log')log.warn("""This is a long message.
It spans multiple lines.
I like pizza.""")produces:[Warning] This is a long message.
|     It spans multiple lines.
|     I like pizza.## Log types

- warn
- error
- deprecation

## Deprecations

`glisten` also provides a deprecation wrapper. One can use it as follows:import glisten
log = glisten.log.Logger('.log')@log.deprecate
def my_deprecated_function():
returnAny time this function is called, glisten will output `Function "my_deprecated_function" is deprecated.`, and log it to file.