Saravanan666/pypi-org huggingface dataset:
Package: gelatin-extract
Gelatin ExtractThis is kind of like Marshmallow, but only does deserialization. What it lacks in reversibility, it makes up for in speed. Schemas are compiled in advance allowing
deserialization to occur very quickly.MotivationI have another package called patent_client. I also do a lot with legal data, some of which is in XML, and some of which is in JSON. But there's a lot of it. And I meana lot, so speed matters.Quick StartThere are two main modules:gelatin_extract.json.schemaandgelatin_extract.xml.schema. Those modules support defining class-style deserializers. Both start by subclassing aSchemaclass, and then defining attributes from thefieldssubmodule.JSON Deserializer Examplefromgelatin_extract.json.schemaimportSchemafromgelatin_extract.json.schemaimportfieldsclassJsonExample(Schema):name=fields.String()birthday=fields.Date("birthdate")deep_data=fields.Int("something.0.many.levels.deep")obj={"name":"Johnny Appleseed","birthdate":"2000-01-01","something":[{"many":{"levels":{"deep":123}}}]}JsonExample().deserialize(obj)# Returns{"name":"Johnny Appleseed","birthday":datetime.date(2000,1,1),"deep_data":123}For JSON, the attributes are filled by pulling values off of the JSON object. If no
path is provided, then the attribute name is used. Otherwise, a dotted string
can be used to pluck an item from the JSON object.XML Deserializer Exampleimportlxml.etreeasETfromsugar.xml.schemaimportSchemafromsugar.xml.schemaimportfieldsclassXmlExample(Schema):name=fields.String("./name")birthday=fields.Date("./birthdate")deep_data=fields.Int("./something/many/levels/deep")obj=ET.fromstring(b"""<xmlObject><name>Johnny Appleseed</name><birthdate>2000-01-01</birthdate><something><many><levels><deep>123</deep></levels></many></something></xmlObject>""".strip())XmlExample().deserialize(obj)# Returns{"name":"Johnny Appleseed","birthday":datetime.date(2000,1,1),"deep_data":123}For XML, the attributes are filled using XPath expressions. If no path is provided,
then the entire object is passed to the field (no implicit paths). Any valid Xpath
expression can be used.
Package: gelatin-mattymar
Gelatin: Python Web Framework built for learning purposesGelatin is a WSGI framework and can be used with any WSGI application server such as Gunicorn.Installationpipinstallgelatin_mattymarHow to use itBasic usage:fromjello.apiimportAPIapp=API()@app.route('/home')defhome(request,response):response.text='Hello from the HOME page'@app.route('/users/{name}')defgreeting(request,response,name):response.text=f'Hello there,{name}'# Class-based handler@app.route('/book')classBooksResource:defget(self,req,resp):resp.text='Books Page'defpost(self,req,resp):resp.text='Endpoint to create a book'# Template handlerdeftemplate_handler(req,resp):resp.body=app.template('index.html',context={"name":"Jello","title":"Awesome framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures
that you may want to use when writing unit tests with Bumbo. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home."withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home2."The other one isclientthat you can use to send HTTP requests to your handlers. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/matthew").text=="hey matthew"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in that folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static FilesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside this folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from thebumbo.middleware.Middlewareclass and overriding its two methods
that are called before and after each request:frombumbo.apiimportAPIfrombumbo.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)
Package: gelato
GeLaTois a python library for the Generalized Locally Toeplitz theory for IsoGeometric Analysis.InstallFrom PyPiSimply run, for a local installation:pip3 install --user gelatoor:pip3 install gelatofor a global installation.From sourcesStandard mode:python3 -m pip install .Development mode:python3 -m pip install --user -e .Examples1- Laplace 2D2- Vibration 1D
Package: gelb
IntroductionGeLB is a tool for quickly developing simulations based on the lattice Boltzmann
(LB) approach. At its core lies the GeLB Description (GD) domain-specific
programming language (DSL), which allows LB (or similar) algorithms to be
expressed in a convenient manner (i.e. as close to the mathematical notation as
possible).This Python package provides thegelbcprogram, which is the reference
implementation of a compiler for the GD language.The intended audience is the community of researchers (or PhD students) who
develop new LB algorithms.Installation (for GeLB users)$ pip3 install gelbUsage (warning: not yet functional!)$ gelbc your_gd_program.gdInformation for GeLB developers (currently, only for Dragos)Technically-speaking,gelbcis only a “transpiler” (rather than a normal
compiler), because currently it only generates high-level language (CorFortran) code, instead of machine code. This might change in future releases.To run tests, use:$ python3 setup.py testTo upload new version to PyPI:$ cd ${GELB_ROOT}
$ # *manually* increment version @setup.py
$ ./utils/scripts_for_devs/cleanup_project.sh
$ python setup.py sdist
$ twine upload dist/*
Package: geld
GeldA library to easily handle currency conversions.Official documentationWe do not have an official documentation yet, we are working on this.Data originCurrently the API used to get the values ishttps://theforexapi.com/api. (If the forex API the default client will not work)
We are working to make the lib extensable so you can pick info from different sources in the future.How to installpip install geldHow to use the Sync ClientCode:fromgeld.clientsimportsync_clientasclientresult=client.convert_currency("USD","BRL",25,"2021-12-05")print(result)Result:141.0127535205030424592109739
Package: gelee
geleeGelee - a finer confiture.Configuration linter for typical formats.UsageUsage documentation.Command Line API.DocumentationUser and developerdocumentation of gelee.Bug TrackerFeature requests and bug reports are best entered in thetodos of gelee.Primary Source repositoryThe primary source ofgeleelives somewhere on a mountain in Central Switzerland.
But, we use decentralized version control (git), so any clone can become the source to everyone's benefit, no central only code.
Anyway, the preferred public clones ofgeleeare:on codeberg- a democratic community-driven, non-profit software development platform operated by Codeberg e.V.at sourcehut- a collection of tools useful for software development.StatusExperimental.Note: The default branch isdefault.
Package: gelfclient
gelfclientPython client for sending UDP messages in Graylog Extended Log Format
(GELF).Messages are zlib compressed, and support GELF chunked encoding.Since messages are sent with UDP, the log method should return quickly
and not raise an exception due to timeout. However an exception may be
raised due to a DNS name resolution failure for the target hostname.Installationpip install gelfclientUsagefrom gelfclient import UdpClient

gelf_server = 'localhost'

# Using mandatory arguments
gelf = UdpClient(gelf_server)

# Using all arguments
gelf = UdpClient(gelf_server, port=12202, mtu=8000, source='macbook.local')

# Bare minimum is to send a string, which will map to gelf['short_message']
gelf.log('server is DOWN')

# 'source' and 'host' are the same. Defaults to socket.gethostname() but can be overridden
gelf.log('server is DOWN', source='hostchecker')

# Set extra fields
gelf.log('status change', _state='DOWN', _server='macbook')

# Set severity level
import syslog
gelf.log('unexpected error', level=syslog.LOG_CRIT)

# You can also prepare all data into a dictionary and give that to .log
data = {}
data['short_message'] = 'warning from python'
data['host'] = 'hostchecker'
data['level'] = syslog.LOG_WARNING
gelf.log(data)See the GELF specification for other fields and their meaning:http://docs.graylog.org/en/latest/pages/gelf.html#gelf-format-specification
Package: gelfHandler
gelfHandler is a basic logging handler for sending to a graylog2 instance via UDP or TCPBasic usageUsage is pretty much like any handler:from gelfHandler import GelfHandler
gHandler = GelfHandler(
    host='mylogserver.example.com',
    port=12202,
    protocol='UDP'
)
logger.addHandler(gHandler)Support for additional fields is available if you send a dict using the extra keyword that begins with gelfProps:logger.warn('DANGER DANGER',extra={'gelf_props':{'name':'W. Robinsson', 'planet':'unknown'}})More info can be found on the github page.
Package: gelutils
Tools and utilities to convert and annotate .GEL or .TIFF image files from e.g. Typhoon scanners and GelDocs.The primary use of this application/package is to add lane annotations to gel images.
The application can be installed and used as any other application,
e.g. by simply double-clicking a .GEL file and then selecting the annotate-gel application to annotate the gel.
It features a simple GUI where you can add the text you want to display above each lane and
configure how the final gel image appears.
Gels can be scaled, cropped, rotated, etc.
The application will export a SVG file with the cropped/rotated gel image, overlayed by the given annotations.
The SVG file can be automatically converted to a PNG, which is sometimes more convenient for presentation usage.FAQ: What are GEL images and who cares?Gels are widely used in molecular biology and biotechnology for analyzing the size of biological molecules, e.g. DNA or
proteins.
When analysing samples on gels via gelelectrophoresis, samples are loaded at the top of the gel in well/indentations at
the top of the gel. Charged molecules are then dragged through the gel by applying an electric field across the gel.
Larger molecules have more interaction with the gel matrix. This drag reduces the migration rate through the gel.
Smaller molecules travels faster through the gel.
This creates a pattern of bands on the gel.
Bands from the a sample in one well will form a vertical “lane” as they travel through the gel.
Package: gelviz
gelviz: A python python package for plotting genomic elements.gelviz is a python package for plotting a wide range of genomic elements in a genome browser-like fashion. It comes with basic plotting functions that can be used for plotting different kind of genomic elements.ExampleThe following example was created using published genomics and epigenomics data from10.5281/zenodo.4557352. The data originates from the publicationF. Haller, M. Bieg, R. Will, et al.. Enhancer hijacking activates oncogenic transcription factor NR4A3 in acinic cell carcinomas of the salivary glands. Nature Communications volume 10, Article number: 368 (2019)Please check thejupyter notebookfor details on how the above figure was created.AcknowledgementsThis package was implemented during my time at theGerman Cancer Research Centerin the group ofTheoretical Bioinformaticsheaded by Prof. Dr. Roland Eils, where i was part of the core bioinformatics team of theHeidelberg Institute of Personalized Oncology (HIPO). Further refinment and final upload to PyPI was done during my time atCharite, Universitaetsmedizin Berlin, Berlin Institute of Health (BIH) in the Department of Digital Healthheaded by Prof. Roland Eils.LicenseCopyright (c) 2021, Matthias BiegRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: gem5art-tasks
gem5art tasks packageThis package contains two parallel task libraries for running gem5 experiments.
he actual gem5 experiment can be executed with the help ofPython multiprocessing support,Celeryor even without using any job manager (a job can be directly launched by callingrun()function of gem5Run object).
This package implicitly depends on the gem5art run package.Please cite thegem5art paperwhen using the gem5art packages.
This documentation can be found on thegem5 websiteUse of Python MultiprocessingThis is a simple way to run gem5 jobs using Python multiprocessing library.
You can use the following function in your job launch script to execute gem5art run objects:run_job_pool([alistcontainingallrunobjectsyouwanttoexecute],num_parallel_jobs=[Numberofparalleljobsyouwanttorun])Use of CeleryCelery server can run many gem5 tasks asynchronously.
Once a user creates a gem5Run object (discussed previously) while using gem5art, this object needs to be passed to a methodrun_gem5_instance()registered with Celery app, which is responsible for starting a Celery task to run gem5. The other argument needed by therun_gem5_instance()is the current working directory.Celery server can be started with the following command:celery-E-Agem5art.tasks.celeryworker--autoscale=[numberofworkers],0This will start a server with events enabled that will accept gem5 tasks as defined in gem5art.
It will autoscale from 0 to desired number of workers.Celery relies on a message brokerRabbitMQfor communication between the client and workers.
If not already installed, you need to installRabbitMQon your system (before running celery) using:apt-getinstallrabbitmq-serverMonitoring CeleryCelery does not explicitly show the status of the runs by default.flower, a Python package, is a web-based tool for monitoring and administrating Celery.To install the flower package,pipinstallflowerYou can monitor the celery cluster doing the following:flower-Agem5art.tasks.celery--port=5555This will start a webserver on port 5555.Removing all taskscelery-Agem5art.tasks.celerypurgeViewing state of all jobs in celerycelery-Agem5art.tasks.celeryeventsTasks API DocumentationTask
----

.. automodule:: gem5art.tasks.tasks
    :members:
    :undoc-members:

.. automodule:: gem5art.tasks.celery
    :members:
    :undoc-members:
Package: gemact
GEMActGEMAct is a comprehensiveactuarial package, based on the collective risk theory framework, that offers a set of tools fornon-life(re)insurancecosting, stochasticclaims reserving, andloss aggregation.The variety of available functionalities makes GEMAct modeling very flexible and provides actuarial scientists and practitioners with a powerful tool that fits into the expanding community ofPythonprogramming language.Please visit ourwebsiteto see our documentation and tutorial.Thepre-printof the accompanying paper is now available.AcknowledgmentsPrevious versions were presented at the Mathematical and Statistical
Methods for Actuarial Sciences and Finance 2022, and at the Actuarial Colloquia 2022, in the ASTIN section.We want to especially thank the students in Statistica per le assicurazioni,
M.Sc. in Economia e Finanza, at the UniversitÃ  Milano-Bicocca for having tested the package.
Package: gemato
Author:Michał GórnyLicense:2-clause BSD licenseIntroductiongemato provides a reference implementation of the full-tree Manifest
checks as specified in GLEP 74[1]. Originally focused
on verifying the integrity and authenticity of the Gentoo ebuild
repository, the tool can be used as a generic checksumming tool
for any directory trees.UsageVerificationThe basic purpose of gemato is to verify a directory tree against
Manifest files. In order to do that, run thegemato verifytool
against the requested directory:gemato verify /var/db/repos/gentooThe tool will automatically locate the top-level Manifest (if any)
and check the specified directory recursively. If a subdirectory
of the Manifest tree is specified, only the specified leaf is checked.Creating new Manifest treeCreating a new Manifest tree can be accomplished using thegemato createcommand against the top directory of the new Manifest tree:gemato create -p ebuild /var/db/repos/gentooNote that for thecreatecommand you always need to specify either
a profile (via-p) or at least a hash set (via-H).Updating existing ManifestsThegemato updatecommand is provided to update an existing Manifest
tree:gemato update -p ebuild /var/db/repos/gentooAlikecreate,updatealso requires specifying a profile (-p)
or a hash set (-H). The command locates the appropriate top-level
Manifest and updates the specified directory recursively.
If a subdirectory of the Manifest tree is specified, the entries
for the specified leaf and respective Manifest files are updated.Utility commandsgemato provides a few other utility commands that provide access to
its crypto backend. These are:gemato hash-H<hashes>[<path>...]Print hashes of the specified files in Manifest-like format.gematoopenpgp-verify[-K<key>][<path>...]Check OpenPGP cleartext signatures embedded in the specified files.gematoopenpgp-verify-detached[-K<key>]<sig-file><data-file>Verify the specified data file against a detached OpenPGP signature.Requirementsgemato is written in Python and compatible with implementations
of Python 3.9+. gemato is currently tested against CPython 3.9
through 3.11 and PyPy3.  gemato core depends only on standard Python
library modules.Additionally, OpenPGP requires system install of GnuPG 2.2+
andrequestsPython module.  Tests requirepytest, andresponsesfor mocking.References and footnotes[1]GLEP 74: Full-tree verification using Manifest files
(https://www.gentoo.org/glep/glep-0074.html)
Package: gematriapy
gematriapyConvert number to Hebrew or Hebrew to numberInstallpipinstallgematriapyUsageto_hebrew:importgematriapygematriapy.to_hebrew(3)# => "ג"gematriapy.to_hebrew(15)# => "טו"gematriapy.to_hebrew(822)# => "תתכב"NOTE: Numbers greater than 999 are not supported yet.to_number:importgematriapygematriapy.to_number("ג")# => 3gematriapy.to_number("טו")# => 15gematriapy.to_number("אבא")# => 4
Package: gemben
GEM-benchmarkDocumentationgemben documentation!IntroductionGraph embedding, which refers to the task of representing nodes of a graph in a low-dimensional space, has gained significant traction in the past few years, with applications including link prediction, node classification, and graph visualization. Many methods have been proposed for this task which primarily differs in the inherent properties being preserved from the original graph. However, comparing such methods is challenging. Most methods show performance boosts on just a few selected networks. Such performance improvement may be due to fluctuations or specific properties of the networks at hand, thus being often inconclusive when comparing methods on different networks. To conclusively determine the utility and advantages of an approach, one would need to make a comparison on several such networks. In this work, we introduce a principled framework to compare graph embedding methods. We test embedding methods on a corpus of real-world networks with varying properties and provide insights into existing state-of-the-art embedding approaches. We cluster the input networks in terms of their properties to get a better understanding of embedding performance. Furthermore, we compare embedding methods with traditional link prediction techniques to evaluate the utility of embedding approaches. We use the comparisons on benchmark graphs to define a score, called GFS-score, that can apply to measure any embedding method. We rank the state-of-the-art embedding approaches using the GFS-score and show that it can be used to understand and evaluate a novel embedding approach. We envision that the proposed framework may serve as a community benchmark to test and compare the performance of future graph embedding techniques.
Package: gemcall
gemcallPython module/CLI program for making network requests with the gemini protocol.Command line usageusage: gemcall [-h] [-c CLIENTCERT] [-k CLIENTKEY] [-u URL] [-o OUTPUTFILE]
               [-t TIMEOUT] [-q] [-n] [-s]

Python module/CLI program for making network requests with the gemini
protocol.

optional arguments:
  -h, --help            show this help message and exit
  -c CLIENTCERT, --clientcert CLIENTCERT
                        Path to client certificate. This is optional, but must
                        be used when -k/--clientkey is used.
  -k CLIENTKEY, --clientkey CLIENTKEY
                        Path to the private key file for a client certificate.
                        This is optional, but must be used when
                        -c/--clientcert is used.
  -u URL, --url URL     Fully qualified URL to fetch.
  -o OUTPUTFILE, --outputfile OUTPUTFILE
                        File to output response body to.
  -t TIMEOUT, --timeout TIMEOUT
                        Timeout of connection attempt, in seconds. Default is
                        3.
  -q, --quiet           Don't print response header.
  -n, --nobody          Only print response header.
  -s, --stdoutonly      Print everything to stdoutInstallationpip install git+https://notabug.org/tinyrabbit/gemcall.git#egg=gemcall
# unofficial package is uploaded on PyPI for convenience
pip install gemcallLibrary Usageimport gemcall

response = gemcall.request(url)

# OR

response = gemcall.request(url, clientcert, clientkey)

while True:
    buf = response.read()
    if len(buf) > 0:
        sys.stdout.buffer.write(buf)
    else:
        break

response.discard()The gemcall.Response object has the following values:serverpubkey: the public key part of the server certificate (the ONLY relevant part in TOFU certificate validation).responsecode: the response code from the server.meta: the rest of the header.The method read() should be used to get content from the response object. It takes an argument 'bufsize', which is how many bytes it will read at most. This defaults to 4096.When you are done reading the response you should use the discard() method to close all file handles and sockets the Response object is handling.CLI Usagegemcall [OPTIONS]FeaturesSupports client certificates.Supports streaming.TodoError checking >.<Validation of response code and meta.