Saravanan666/pypi-org huggingface dataset:
Package: gldas
Readers and converters for data from theGLDAS Noah Land Surface Model. Written in Python.Works great in combination withpytesmo.CitationIf you use the software in a publication then please cite it using the Zenodo DOI.
Be aware that this badge links to the latest package version.Please select your specific version athttps://doi.org/10.5281/zenodo.596427to get the DOI of that version.
You should normally always use the DOI for the specific version of your record in citations.
This is to ensure that other researchers can access the exact research artefact you used for reproducibility.You can find additional information regarding DOI versioning athttp://help.zenodo.org/#versioningInstallationSetup of a complete environment withcondacan be performed using the following
commands:condacreate-ngldaspython=3.9# or any other supported python versionsourceactivategldas# Either install required conda packages manuallycondainstall-cconda-forgenumpynetCDF4pyprojpygribpyresample-ngldas# Or use the provided environment file to install all dependenciescondaenvupdate-fenvironment.yml-ngldas# Install the latest gldas package and its pip-dependenciespipinstallgldasSupported ProductsAt the moment this package supports GLDAS Noah data version 1 in grib
format (reading, time series creation) and GLDAS Noah data version 2.0 and version 2.1 in netCDF format (download, reading, time series creation) with a spatial sampling of 0.25 degrees.
It should be easy to extend the package to support other GLDAS based products.
This will be done as need arises.ContributeWe are happy if you want to contribute. Please raise an issue explaining what is missing or if you find a bug. We will also gladly accept pull requests against our master branch for new features or bug fixes.Development setupFor Development we also recommend acondaenvironment. You can create one
including test dependencies and debugger by runningconda env create-fenvironment.yml. This will create a newgldasenvironment which you can activate by usingsource activate gldas.GuidelinesIf you want to contribute please follow these steps:Fork the gldas repository to your accountClone the repository, make sure you usegit clone--recursiveto also get the test data repository.make a new feature branch from the gldas master branchAdd your featurePlease include tests for your contributions in one of the test directories. We use py.test so a simple function called test_my_feature is enoughsubmit a pull request to our master branchNoteThis project has been set up using PyScaffold 2.5.6. For details and usage
information on PyScaffold seehttp://pyscaffold.readthedocs.org/.
Package: gldf-rs-python
gldf-rs-pythonSome more descriptive info in the Cargo.toml file
Added the build.rs mostly bcs of macOSv0.2.0
New:
support for file types of url
support for BOM encoded UTF8 product.xmlWIP python module and binding for the gldf-rs rust librarythe github workflow shall make sure all the wheels are buildand published to pypiinstall via pip:pip install gldf-rs-pythoncreate venv and maturinmaturin developimport gldf_rs_python

xml = gldf_rs_python.gldf_to_xml('tests/data/test.gldf')

json = gldf_rs_python.gldf_to_json('tests/data/test.gldf')

xml2 = gldf_rs_python.xml_from_json(json)

xml == xml2=> True
Package: gldpy
gldpygldpy is Python package that implements  tools for using Generalized Lambda Distribution (GLD) of three different parameterization types.GLD is flexible family of continuous probability distributions with wide variety of density shapes under one functional form. It specified by four parameters which determine location, scale and shape (skewness and kurtosis) of the distribution.GLD is easily described in terms of quantile function which makes it easy to use in simulation studies.It can approximate a lot of well-known distributions such as normal, uniform, exponential, Student's, gamma, some of beta distributions and many others.GLD shapes can be symmetric or asymmetric  and have different combination of finite and infinite tails, they include unimodal, U-shaped, J-shaped and monotone density functions. So it is particularly useful tool for data fitting applications.For more information, see the documentation.Usage exampleshttps://github.com/alexsandi/using_gldpyReferencesChalabi, Y., Scott, D.J., & Wuertz, D. 2012. Flexible distribution modeling with the generalized lambda distribution.Cheng, R.C.H., & Amin, N.A.K. 1983. Estimating parameters in continuous univariate distributions with a shifted origin. Journal of the Royal Statistical Society: Series B (Methodological), 45(3), 394вЂ“403.Freimer, M., Kollia, G., Mudholkar, G.S., & Lin, C.T. 1988. A study of the generalized Tukey lambda family. Communications in Statistics-Theory and Methods, 17, 3547вЂ“3567.Karian, Z.A., Dudewicz, E.J. 2000. Fitting statistical distributions: the generalized lambda distribution and generalized bootstrap methods. Chapman and Hall/CRC.Karvanen, J. and Nuutinen, A. 2008. Characterizing the generalized lambda distribution by L-moments. Computational Statistics & Data Analysis, 52(4):1971вЂ“1983.King, R. A. R., and MacGillivray, H. L. 1999. "A Starship Estimation Method for the Generalized Lambda Distributions," Australian and New Zealand Journal of Statistics, 41, 353вЂ“374.Ramberg, J.S., & Schmeiser, B.W. 1974. An approximate method for generating asymmetric random variables. Communications of the ACM, 17(2), 78вЂ“82Ranneby, B. 1984. The maximum spacing method. an estimation method related to the maximum likelihood method. Scandinavian Journal of Statistics, 93вЂ“112.Su, S. 2007. Numerical maximum log likelihood estimation for generalized lambda distributions. Computational Statistics & Data Analysis, 51(8), 3983вЂ“3998.Van Staden, Paul J., & M.T. Loots. 2009. Method of L-moment estimation for generalized lambda distribution. Third Annual ASEARC Conference. Newcastle, Australia.
Package: glean-cli
glean-cliCommand-line tools for interacting with Glean (https://glean.io).DevelopmentDuring local development, you likely want to point the CLI at your local
Glean web server. You can do so with the following environment variable:exportGLEAN_CLI_BASE_URI=http://localhost:5000You should work with the Glean CLI in its own virtual environment. In this
new environment, ensure you havepip, then dopip install buildto get
the correct build tool.The Glean CLI is a project built bysetuptools. You can package it for
publish withpython -m build, or link it for local development by runningpip install --editable .in the root folder of this repo.Once installed as an editable package, runglean --helpto use it.
Package: gleandoc
Convenience functions to extract docstring and write READMEIntent: store one copy of top-level docstring in <package>/__init__.pyAllows generation of top level gitub README based on the package docstringFeaturesDetermine package name from current directoryExtract docstring using Python semantics and standardsNo dependencies outside standard libraryUses abstract syntax tree parsing for relative __init__.py filesExamplesPrint the first line of a docstring:>>>importgleandoc>>>docstring=gleandoc.docstring('re')>>>docstring.splitlines()[0]'Support for regular expressions (RE).'>>>Do the same thing from the command line:$gleandocre|head-1Support for regular expressions (RE).$Interpolate template README.rst.fstr and write results to README.rst,
replacing {__doc__} with extracted docstring based on the name of the
current directory:$gleandocREADME.rst.fstrREADME.rstgleandoc: WARNING: replacing README.rst
gleandoc: INFO: wrote README.rst$The -h option at the command line will show supported options:$gleandoc-hUsage: gleandoc [-h] [NAME]
Extract docstring from module [NAME]

  -h, --help            show this help message and exit

- If unspecified, NAME defaults to the basename of the current directory
- This is designed for use in build systems to construct README files

Alternative two argument usage: gleandoc TEMPLATE README
Interpolate docstring into TEMPLATE and write results to README

- In this mode, always derives NAME from basename of current directory
- Template uses style similar to f-string
- Supported variables which will be interpolated include: {__doc__}
- For literal (single) braces, use double braces: {{ or }}LimitationsEmbedded backslash-n newlines are treated as actual newlinesRelies on various pseudo-internals: locals(), exec()CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: gleaner
Gleaner: Multi-Criteria Optimization for Automatic Dashboard DesignGleaneris an automatic dashboard design system that optimizes the design in terms of four design criteria, namely Specificity, Interestingness, Diversity, and Coverage. With these criteria, Gleaner not only optimizes for the expressiveness and interestingness of a single visualization but also improves the diversity and coverage of the dashboard as a whole. Users are able to express their intent for desired dashboard design to Gleaner, including specifying preferred or constrained attributes and adjusting the weight of the Oracle. This flexibility in expressing intent enables Gleaner to design dashboards that are well-aligned with the user's own analytic goals leading to more effective and efficient data exploration and analysis.Installationpip install gleanerUsage ExampleDetailed documentations are under construction!fromgleanerimportGleanergl=Gleaner(df)gl.train(["rect","count","Creative_Type"])gl.infer().display()Demo for Gleaner LibraryDemo for Web-based InterfaceTBADevelopmentTBAReferenceMulti-Criteria Optimization for Automatic Dashboard DesignJiwon Choiand Jaemin JoPresented in 2023 Eurographics Conference on Visualization (EuroVis), Leipzig, GermanyInvited to IEEE Pacific Visualization Symposium 2023, Seoul, Korea
Package: glean-sdk
Glean SDKDocumentationAll documentation is available online:The Glean SDK BookOverviewRefer to the documentation forusinganddevelopingthe Glean SDK.For an overview of Glean beyond just the SDK, see thesection in the Firefox data docs.The code in this repository is organized as follows:./glean-core/contains the source for the low-level Rust library../glean-core/rlbcontains the high-level Rust library../glean-core/androidcontains the Kotlin bindings for use by Android applications../glean-core/ioscontains the Swift bindings for use by iOS applications../glean-core/pythoncontains Python bindings.Note: The Glean SDK requires at leastRust 1.66.0. Older versions are untested.ContactTo contact us you can:Find us in the#glean channel on chat.mozilla.org.To report issues or request changes, file a bug inBugzilla in Data Platform & Tools :: Glean: SDK.Send an email toglean-team@mozilla.com.The Glean Core team is::dexter,:janerik,:travis_,:chutten,:brizental.CreditsTheGlean logo artworkwas contributed byDiana Ciufo.
It's licensed under MPL.Alumni contributorsGeorg FritzscheMichael DroettboomSee the full list of contributors for:theGlean SDKtheGlean.js SDKtheglean_parserLicenseThis Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/
Package: glearn
glearnis a modular and high-performance Python package for machine learning usingGaussian process regression with novel algorithms capable of petascale computation on multi-GPU devices.LinksDocumentationPyPIAnacondaDocker HubGithubInstallInstall withpippip install glearnInstall withcondaconda install -c s-ameli glearnDocker Imagedocker pull sameli/glearnSupported PlatformsSuccessful installation and tests performed on the following operating systems, architectures, and Python andPyPyversions:PlatformArchDevicePython VersionPyPy Version1Continuous
Integration3.93.103.113.123.83.93.10LinuxX86-64CPU✔✔✔✔✔✔✔GPU✔✔✔✔✔✔✔AARCH-64CPU✔✔✔✔✔✔✔GPU✔✔✔✔✔✔✔macOSX86-64CPU✔✔✔✔✔✔✔GPU✖✖✖✖✖✖✖ARM-64CPU✔✔✔✔✔✔✔GPU✖✖✖✖✖✖✖WindowsX86-64CPU✔✔✔✔✖✖✖GPU✔✔✔✔✖✖✖Python wheels forglearnfor all supported platforms and versions in the above are available throughPyPIandAnaconda Cloud. If you needglearnon other platforms, architectures, and Python or PyPy versions,raise an issueon GitHub and we build its Python Wheel for you.1. Wheels for PyPy are exclusively available for installation through pip and cannot be installed using conda.2. Wheels for Windows on ARM-64 architecture are exclusively available for installation through pip and cannot be installed using conda.Supported GPU Architecturesglearncan run on CUDA-capablemulti-GPU devices. Using thedocker containeris the easiest way to runglearnon GPU devices. The supported GPU micro-architectures and CUDA version are as follows:Version \ ArchFermiKeplerMaxwellPascalVoltaTuringAmpereHopperCUDA 9✖✖✖✖✖✖✖✖CUDA 10✖✔✔✔✔✔✔✔CUDA 11✖✖✖✔✔✔✔✔CUDA 12✖✖✖✔✔✔✔✔DocumentationSeedocumentation, including:What This Packages Does?Comprehensive Installation GuideHow to Work with Docker Container?How to Deploy on GPU Devices?API ReferenceInteractive Notebook TutorialsPublicationsHow to ContributeWe welcome contributions viaGitHub’s pull request. If you do not feel comfortable modifying the code, we also welcome feature requests and bug reports asGitHub issues.How to CiteIf you publish work that usesglearn, please consider citing the manuscripts availablehere.LicenseThis project uses aBSD 3-clause license, in hopes that it will be accessible to most projects. If you require a different license, please raise anissueand we will consider a dual license.
Package: gleeful
This wraps the very usefulHAP-pythonpackage to make creating new Accessories,
especially those with multiple services, really simple.Here is an example:class Temperature(gleeful.Accessory):
    temperature = gleeful.services.temperature.DS18B20(sensor_id='28-00000000000')

    class AccessoryInformation:
        Name = 'Temperature'
        Manufacturer = 'Matthew Schinckel'
        Model = 'DS18B20'
        SerialNumber = '28-00000000000'


Temperature(persist_file='/path/to/temperature.state').start()Defining ServicesServices must inherit fromgleeful.Servicein order for them to be correctly registered
with the accessory, and for the service attribute to be correctly determined:class PIR(gleeful.Service):
    service = 'MotionSensor'

    def __init__(self, *args, **kwargs):
        from gpio import MotionSensor
        self.motion = self.service.get_characteristic('MotionDetected')
        self.detector = gpiozero.MotionSensor(kwargs.pop('gpio_pin'))
        super().__init__(*args, **kwargs)

    def run(self, sentinel):
        self.detector.when_motion = lambda: self.motion.set_value(True)
        self.detector.when_no_motion = lambda: self.motion.set_value(False)You will note a few things that are quite important in this example:You define the service on tha class as a string: this will be looked up from
the HAP loader automatically, when using a class the service attribute will
not be a string, but instead an instance of the HAP service that matches.The run method takes an extra argument: the sentinel that can be used to
trigger repeating code or a stop situation. This is shared between all
services within an accessory.Why use this instead ofHAP-python?Gleeful makes it easy to have multiple services within a single accessory, and
encapsulating the logic within the service.It also allows for you to serve directly from the accessory, by using.start(),
although you may also pass the accessory to a driver if you wish.
Package: gleichgewicht
gleichgewichtOverviewThe "gleichgewicht package" is designed for students at the Hochschule Luzern Technik & Architektur, with a specific focus on structural engineering. This package provides a comprehensive set of tools for analyzing structures and understanding the principles of gleichgewicht.Key FeaturesEquilibrium Analysis:The core functionality of this package revolves around the analysis of structures using the principles of gleichgewicht. It allows students to input action forces and calculate the resulting reaction forces within a given system. The package is only capable of two-dimensional analysis.Jupyter Environment:The package is compatible with Jupyter notebooks, making it a versatile and interactive learning tool. Students can experiment with different scenarios and visualize the outcomes of their analyses.UsageThis package is intended to be used as a learning aid for students studying structural engineering. It empowers them to:Understand the principles of gleichgewicht and its application in structural analysis.Gain practical experience in calculating reaction forces based on given action forces.Experiment with various structural configurations and scenarios in a Jupyter notebook environment.Getting StartedTo get started with the "Structural Equilibrium Analysis Package," follow these steps:Install the package using the provided installation instructions. Create a new virtual environment to reduce conflicts.pip install gleichgewichtImport the package into your Jupyter notebook or Python environment.Explore the package's examplesDisclaimerThis package is intended for educational purposes and should be used in conjunction with classroom instruction and academic guidance. It is not a substitute for professional structural engineering software or expertise. Users are responsible for ensuring the accuracy and appropriateness of their analyses when applying the concepts learned through this package to real-world projects.
Package: gle-ip-info
gle_ip_infoglip is a module for retrieve ip address like local-ip, global-ip, external-ip as string.InstallationRun the following to install:'''python
pip install gle_ip_info
'''Usage'''
from gle_ip_info import IPIp = IP() # Initialize the IP classos = Ip.Os # To get your os info.dev = Ip.devices # Gives connected devices as list.local_ip = Ip.get_local_ip() # TO get your local ipaddress.global_ip = Ip.get_global_ip() # To get your global ipaddress.external_ip = Ip.get_external_ip() # To get external(of connected device) ipaddress, returns the ip address of 1st device
'''How it worksIt use's -->
'''
--> os module,
--> requests module,
--> platfrom module,
--> upnpclient module.***Local_IP is collected from the cmd(in Windows) or Bash-Terminal(in Linux) using 'ipconfig'/
'hostname -I' command.So there is no need to get the hostname like socket module does and
the accuracy of the output is 100% in Linux Os.***Global_IP is collected by sending request to 'https://checkip.amazonaws.com' or
'https://www.wikipedia.org' using python requests module.So to get the global_ip a stable
net connection is needed.***External_IP  of any router or alike devices can be collected using upnpclient module.
It takes a little more time to get the external_ipaddress Compare to other two functions.Though it don't require
stable Internet connection but requires a stable connection between the devices.
'''LicenseMIT License
Package: gleipnir
Hold Fenrir 🐺Tool to easily connect to your AWS serversInstall$ pip install gleipnirUsage$ gleipnir connect -s “my server name tag”Searches for EC2 instances by Name tag (regex enabled)When more than one instance is found it returns a list.
If just one instance is found it connects.$ gleipnir connect -h 192.168.1.1Connects to server by IP/URLEnvironment variablesYou should set the following environment variables:AWS_ACCESS_KEY_ID: your AWS access key idAWS_SECRET_ACCESS_KEY: your AWS secret access keyAWS_REGION: your AWS regionAWS_PASSWORD: custom password for SSH (optional)AWS_KEY_FILE: location of your key fileThanksMopinion.com
Package: glenda
Tools for glendaThis is some tools for glenda projectsHow to build# Build new version 
python3 -m pip install --user --upgrade setuptools wheel
python3 setup.py sdist bdist_wheel

# For publish new version
python3 -m pip install --user --upgrade twine
python3 -m twine upload dist/*If you use proxyset HTTP_PROXY=http://<your proxy with port>/  && set HTTPS_PROXY=https://<your proxy with port>/ && python3 -m twine upload dist/*
Package: glenoidplanefitting
Authors: Asta Olafsdottir, Stephen Thompsonglenoidplanefitting provides tools for measuring the Glenoid version, useful when
planning reconstructive shoulder surgery.
glenoidplanefitting is part of thescikit-surgerysoftware project,
developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences,
part ofUniversity College London (UCL), in collaboration with surgeons at the
Royal National Orthopaedic Hospitalglenoidplanefitting is tested on Python 3.x, but may work with other versions of Pythonglenoidplanefitting currently requires the user to manually identify relevant anatomical
landmarks on the scapula and glenoid dish. These points can then be passed to
glenoidplanefitting to calculate the Glenoid version using multiple methods. Example usage:python glenoidplanefitting.py --fried_points landmark_friedman.fcsv --output friedman.vtp --visualise glenoid.vtpglenoidplanefitting is a work in progress with plans to automate the point picking to create
software to enable a large scale comparison of different methods of Glenoid version
methods on a clinical data set. If you are interested in contributing to this work
please get in touch or follow the guides below.DevelopingCloningYou can clone the repository using the following command:git clone https://github.com/SciKit-Surgery/glenoidplanefittingRunning testsWe use tox to run tests and run static code analysis using Lint.pip install tox
python -m toxInstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/SciKit-Surgery/glenoidplanefittingContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2021 University College London.
glenoidplanefitting is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: glerbl
Glerbl is a tool to help manage git hooks and promote consistent
coding standards among contributors to a repository.Let’s say you maintain a github repository for which you want to ensure
the following coding standards:No trailing spaces.No non-ascii file names.All python code must conform to pep8.You can hope that contributors will remember to run the necessary
checks before they send in pull requests or push code to the
repository.Or you can use glerbl to formalize your requirements and provide all
collaborators with the means to detect problems and fix these problems
before they commit.
Package: glespy
This package contains line bindings forGLESPwith some ‘candies’:InstallationRequirementsGLESPmust be installed with all
dependences for normal work;numpyto work with dl$eog(to show maps).InstallationTo install package just input to command line:pip install glespyUsingTo use in python you need to import glespy packageimport glespyFeaturesAutomated parameters control, i.e.:lmin >= 0
lmax >= lmin
nx >= lmax * 2 + 1
np >= nx * 2PixelMapClass forGLESPfits pixel maps. Possible
operations are:arithmetics (+, -, *, …);convert from almGLESPfiles;draw map (witheog, if it’s
installed);get map attributes;cut/keep zones;reflect map;mask map;get C(l), alm and gif.AlmClass forGLESPfits alm. Operations:get attributes;convert toGLESPpixel map;smooth;rotate;get C(l).PointSourceClass for gettingGLESPfits map from
file with ascii values. It can be with point sources or pixel map in
ascii format. Operations:get pixel map;show.ClClass for manipulating with angular power spectrum. Operations:convert to alm;convert to pixel map.Changes0.1.7.2Dl data type now is float32 from numpy0.1.7.1Calculation of D() from alm and pixelmap0.1.7Class for power spectrum added0.1.6.1description updated0.1.6quick update alm lmax and lmintemp maps and alm`s autoremovepointsource can be made of asci file from/for pixelmappython2.6 particle compatibility
Package: glest
glest: Estimation of the grouping loss of a probabilistic classifierInstallFrom PyPi:pip install glestFrom source:pip install git+https://github.com/aperezlebel/glest.gitCite@inproceedings{perez-lebel2023,title={Beyond calibration: estimating the grouping loss of modern neural networks},author={Alexandre Perez-Lebel and Marine Le Morvan and Gaël Varoquaux},booktitle={Proceedings of the International Conference on Learning Representations},year={2023},url={https://doi.org/10.48550/arXiv.2210.16315}}