Saravanan666/pypi-org huggingface dataset:
Package: gaiacalc
Gaia calculator for White DwarfsGaia is a space observatory of the European Space Agency (ESA). The mission aims to construct the largest and most precise 3D space catalog.EDR3 - Early Data Release 3 - was released on 3 December 2020.DR3 - 3rd data release - was released on 13 June 2022.Those catalogs include 1811709771 objects. Data is freely downloadable from ESA servers.The DR3 database contains more than 200 parameters for each space object.The Universitat Politècnica de Catalunya · BarcelonaTech (UPC) makes available a tool to compute the mass and temperature of White Dwarfs stars. This tool is based on data abacus, spatial index, and interpolation.Any input file with CSV format is accepted, provided that is contains at least 3 columns with values for BP-RP, Gabs and probability.The tool will add 2 more columns with mass and Teff of the star.The tool is available as :- online access here : http://gaia.doligez.fr- MacOS application- Windows exe file- Python package- linux debian package- GitHub source codeSee PACKAGING.txt to be able to generate any or all of these deliveries from the source code.Julie Doligez
Package: gaia-cmd-plotter
gaia-cmd-plottergaia_cmd_plotteris a Python package for creating customized Matplotlib axes that display a Gaia Color-Magnitude
Diagram (CMD) background. This package is useful for visualising astronomical data within the context of a Gaia CMD.InstallationYou can install gaia_cmd_plotter usingpip:pipinstallgaia-cmd-plotterUsageTo use the package, first import theGaiaCMDAxisclass from thegaia_cmd_plotter.gaia_cmd_plottermodule.fromgaia_cmd_plotter.gaia_cmd_axisimportGaiaCMDAxisNext, create a newGaiaCMDAxisobject and add it to a Matplotlib figure.importmatplotlib.pyplotaspltfig=plt.figure(figsize=(8,8))ax=GaiaCMDAxis(fig)You can then use theGaiaCMDAxisobject like any other Matplotlib axis. For example, you can plot data on top of
the Gaia CMD background,bp_rp=3.5g_abs=5.0ax.plot(bp_rp,g_abs,"ko",ms=10,mec="k")AcknowledgementsThis package has made use of data from the European Space Agency (ESA)Gaia mission,
processed by theGaia Data Processing and Analysis Consortium.
The CMD background data was obtained from the Gaia data release 3 (DR3; Gaia Collaboration et al. 2016, 2023). The bulk
of points in the CMD background are retrieved from the Gaia DR3 catalog, using the query in Gaia Collaboration 2018.ReferencesGaia Collaboration, 2016, A&A, 595, A1Gaia Collaboration, 2018, A&A, 616, A10Gaia Collaboration, 2023, A&A, 674, A38
Package: gaia-communication
Gaia Boat - communication moduleAbout the Gaia BoatThe Gaia Boat is an autonomous boat designed to collect trash from a lake’s shore. It uses image processing to detect obstacles and trash, an app for tracing routes and a series of other embedded software for controlling the hardware.Other Gaia Boat’s software linksgaia routergaia controlgaia appgaia communicationgaia image processingCommunication moduleUsage and installationUsageThis module is used to establish communication between the Raspberry Pi 3 and a ASP module. With both of them having different electronics and sensors attached like GPS, MPU and Bluetooth.InstallationTo install the package you must install if through pip, using the following command:pipinstallgaia-communicationIf you want to upgrade its version you must use:pipinstall--upgradegaia-communication
Package: gaia-control
The Gaia Boat is an autonomous boat designed to collect trash from a lake’s shore. It uses image processing to detect obstacles and trash, an app for tracing routes and a series of other embedded software for controlling the hardware.Other Gaia Boat’s software linksgaia routergaia controlgaia appgaia communicationgaia image processingThe control moduleUsage and installationUsageThis module is used to represent the internal state-driven machine, modeled afterPetri’s Net, that is the core of the Gaia Boat project’s operational logic, while doing the integration between sensors, electronic components and high level software.InstallationTo install the package you must install if through pip, using the following command:pipinstallgaia-controlOr adding it into your requirements file. You can see the latest versionHERE.If you want to upgrade its version you must use:pipinstall--upgradegaia-controlNote:this module has every other Gaia software as dependency, the only exception is the mobile app.
Package: gaia-core
gaia-sdkgaia sdk#how to install
pip install gaia-core#how to use# add .vendors_keys file including# OPEN_AI_KEY=# COHERE_AI_KEY=# or# use dict api_keys dictimportgaiadebug=Trueapi_keys={"OPEN_AI_KEY":"","COHERE_AI_KEY":""}GAIA=gaia.init(api_token='',api_keys=api_keys,debug=debug)prompt='find the sentiment for the following text <TEXT>, provide only Positive or Negative or Neutral answers'prompt_template=GAIA.optimize_prompt(prompt)golden_dataset:list=GAIA.load_data('local_dataset.csv')vendors:list=GAIA.get_available_vendors()prompts=[prompt_template.replace('<TEXT>',row['prompt'])forrowingolden_dataset]results=GAIA.run_vendors(vendors=vendors,data=prompts)vendors_results=results['vendors_results']total_took=results['total_took']compared_vendors=results['compared_vendors']GAIA.save_csv('Sentiment_gai.csv',data=vendors_results)
Package: gaiadr3-zeropoint
gaiadr3_zeropointThis Python package contains the necessary tools to query the value of the parallax zero-point for Gaia EDR3  and
Gaia DR3. Based on the functions described in Lindegren et al. 2020, the code returns the estimated parallax zero
-point given the ecliptic latitude, magnitude and colour of any Gaia (E)DR3 source.NOTE: the zero-point returned by the code should besubtractedfrom the parallax value given in the Gaia archive. Runhelp(zpt.get_zpt)for more details.DocumentationAll classes and methods/functions are documented so use the python help() function to find out more.InstallationThis is a Python3 package (issues may arise if executed with Python2).The required dependencies are:numpypandas(only if you want to use the wrapper provided with the code)To install the package:From source (recommended)Clone the Github repository or download the source filescd to the directoryRunpython setup.py installorpython setup install --userfor installation in your own home directoryWith pippip install gaiadr3-zeropointBasic usageOnce the package is installed, you can import it in Python:from zero_point import zptThen, first load the coefficient tables by calling theload_tables()function.Once the tables are loaded, the
parallax zero-point can be queried as:zpt.get_zpt(phot_g_mean_mag, nu_eff_used_in_astrometry, pseudocolour, ecl_lat, astrometric_params_solved)This function accepts both single values as well as iterables, and returns a float (or array of such) corresponding to the zero-point of the source(s) with those parameters.NOTE: for 5-p solutions (ra-dec-parallax-pmra-pmdec), the fieldastrometric_params_solvedequals 31 and thepseudocolourvariable can take any arbitrary values (evenNone). On the other hand, for 6-p solutions (ra-dec
-parallax-pmra-pmdec-pseudocolour), the fieldastrometric_params_solvedequals 95 and thenu_eff_used_in_astrometryvariable can take any arbitrary values (evenNone).Finally, if you have a pandas DataFrame (DF) of sources with the columnsphot_g_mean_mag, nu_eff_used_in_astrometry, pseudocolour, ecl_lat, astrometric_params_solved, you can simply use the pandas wrapperzpt_wrapper:zero_point = DF.apply(zpt_wrapper,axis=1)AttributionIf you make use of this package for your research, please acknowledge the following papers: Lindegren+20.HelpIf you encounter any problem with the software, please make use of the GitLub Issues page. Otherwise, contactpau.ramos@nao.ac.jp.Copyright: Pau Ramos, University of Barcelona
Package: gaiaFramework
gaia-frameworkgaia framework#how to install
pip install gaiaframework#how to use
##list of commands:gaia-cli - to get all cli optionsgaia-cli generate project my-new-project - to generate new project named my-new-projectinside generated project folder(cd my-new-folder)gaia-cli g forcer my-new-forcer - creating new forcer (will be automatically injected to pipeline after last exist forcer)gaia-cli g predictable my-new-predictable - creating new predictable (will be automatically injected to pipeline after last exist predictable)gaia-cli run-server - will run local server with port 8080available endpoints depend on projecthttp://localhost:8080/parse,http://localhost:8080/predictwill validate input based on input scheme and execute pipelinehttp://localhost:8080/testwill run mock test using Data science portalgaia-cli create-deploy-files - deploy files generated automatically when creating new project this is an option to create all non exist deploy files,if deploy file was deleted by mistake you can recreate itif gaiaframework version was update with updated deploy files you can delete deploy files and recreate themgaia-cli create-cloud-eval-files - cloud eval files this is an option to create all non exist cloud eval files
Package: gaia-lib
gaia-sdkgaia sdk#how to install
pip install gaia-lib#how to use# add .vendors_keys file including# OPEN_AI_KEY=# COHERE_AI_KEY=# or# use dict api_keys dictimportgaiadebug=Trueapi_keys={"OPEN_AI_KEY":"","COHERE_AI_KEY":""}GAIA=gaia.init(api_token='',api_keys=api_keys,debug=debug)prompt='find the sentiment for the following text <TEXT>, provide only Positive or Negative or Neutral answers'prompt_template=GAIA.optimize_prompt(prompt)golden_dataset:list=GAIA.load_data('local_dataset.csv')vendors:list=GAIA.get_available_vendors()prompts=[prompt_template.replace('<TEXT>',row['prompt'])forrowingolden_dataset]results=GAIA.run_vendors(vendors=vendors,data=prompts)vendors_results=results['vendors_results']total_took=results['total_took']compared_vendors=results['compared_vendors']GAIA.save_csv('Sentiment_gai.csv',data=vendors_results)
Package: gaiaunlimited
gaiaunlimitedgaiaunlimited is a package for querying and constructing selection functions for the Gaia survey. It is developed by the GaiaUnlimited collaboration.The documentation for gaiaunlimited is hosted onRead the docs.TheGaiaUnlimitedproject is funded by the European Union’s Horizon 2020 research and innovation program under grant agreement No 101004110.FeaturesQuery Gaia scanning laws for when a given sky position is scanned.Query Gaia survey selection functions for the probabilities that sources of given properties are included in the Gaia catalog.Query ready-made Gaia DR3 subsample selection functions forthe astrometry samplethe RVS sampleother subsets of the Gaia catalogAcknowledgementsThis work is part of the GaiaUnlimited project funded by the European Union’s
Horizon 2020 research and innovation program under grant agreement No 101004110.
Package: gai-cli
Install Depssudoapt-get-qqinstallpoppler-utilstesseract-ocrpandoc
pipinstall-q--user--upgradepillow
pipinstall-q"unstructured[all-docs]"pipinstallnltk
python-c"import nltk; nltk.download('punkt')"python-c"import nltk; nltk.download('averaged_perceptron_tagger')"
Package: gaidaros
Gaidaros is an async socket server framework which has been
designed for network developers, with an emphasis on easy
low-level configurability and speed, with sane standard
defaults. This means it can be quickly reused and adapted
to each new project’s requirements, while keeping features
out of the way unless requested.Its first iteration is presently in alpha phase (e.g.
edge-triggered epoll only), but has a clear list of
development milestones ahead. See the TODO.rst file for
details.Gaidaros (Γάιδαρος) is Greek for donkey. I like donkeys.
This framework doesn’t try to implement every trendy feature
under the sun, it just tries to do all the basics accurately
and reliably - like a donkey. So, that’s the naming rationale
issue out of the way…FeaturesMinimalism (priority on leanness, speed, configurability
and base completeness rather than added features)Thin wrapper to underlying async socket mechanismsEverything configurable by config-files and passed
argumentsPass in handlers by name, (module, class) or as
pre-created functions, methods or code objectsTODO: Multiple server processors can be run on the polling
socket using multiprocessing (or a pool thereof)TODO: Handlers can be run in threads, greenthreads,
multiprocesses, and pools of any of those threeTODO: Handlers can be run on a cluster using parallel
processing (“pp”/”pyparallel”). Cluster nodes can in turn
use threads, greenthreads, multiprocesses, or pools
thereof tooIPv4 and/or IPv6, SSL (TLSv1, SSLv3, SSLv23) or notTCP,TODO: UDP, unixsocket, etcTODO: Can be used with various frontends (e.g. Tornado)InstallationFrom pypi$ pip install gaidarosFrom source$ git clone https://github.com/rowanthorpe/gaidaros.git
$ cd gaidaros && pip install -r requirements.txtFrom latest released tarball$ wget --no-check-certificate https://github.com/rowanthorpe/gaidaros/tarball/0.3.13Build StatusWhen properly integrated with Travis the project’s status
should appear below this:AuthorsRowan Thorpe <rowan@rowanthorpe.com>LicenseGaidaros uses the MIT license, check LICENSE file.ContributorsJust Rowan Thorpe, so far…Thanks also toScott Doyle for thewell-written blog-post about epollwhich inspired me to start this project.“Donkey kiss” image fromflickr(CC BY-NC-SA 2.0)
Package: gain-imputer
GAIN ImputerOverviewGAIN (Generative Adversarial Imputation Networks) is a Python library for imputing missing values in a dataset using the GAIN model. It provides a convenient implementation to handle missing data, allowing users to train the imputer and apply it to new data.This is an adoption of the work done:https://github.com/jsyoon0823/GAINimplemented in torch and provides a familiar workflow to sklearn.Installation$pipinstallgain-imputerUsageGain requires indices of categorical columns to be provided as a list in order to round them properly.fromgain_imputerimportGainImputercat_columns=[0,1,2]gain_imputer=GainImputer(dim=data_with_nans.shape[1],h_dim=128,cat_columns=cat_columns)imputed_data=gain_imputer.fit_transform(data_with_nans)Full examplefromgain_imputerimportGainImputerimportnumpyasnpfromsklearn.datasetsimportload_breast_cancerfromsklearn.model_selectionimporttrain_test_splitfromsklearn.ensembleimportRandomForestClassifierfromsklearn.metricsimportaccuracy_score,f1_score# Sample datacancer=load_breast_cancer()X,y=cancer.data,cancer.target# Introducing missing datanan_percentage=0.5num_nans=int(np.prod(X.shape)*nan_percentage)nan_indices=np.random.choice(np.arange(np.prod(X.shape)),size=num_nans,replace=False)X_flat=X.flatten()X_flat[nan_indices]=np.nanX_with_nans=X_flat.reshape(X.shape)X_train,X_test,y_train,y_test=train_test_split(X_with_nans,y,test_size=0.2,random_state=42)# GAIN Imputer setupcat_columns=[0,1]gain_imputer=GainImputer(dim=X_with_nans.shape[1],h_dim=128,cat_columns=cat_columns,batch_size=1024)# Simple fit_transformimputed_gain_train=gain_imputer.fit_transform(X_train)imputed_gain_test=gain_imputer.fit_transform(X_test)# Model trainingregressor=RandomForestClassifier(n_jobs=-1)regressor.fit(imputed_gain_train,y_train)pred=regressor.predict(imputed_gain_test)# Evaluate performanceprint("Accuracy:",accuracy_score(pred,y_test))print("F1 Score:",f1_score(pred,y_test))Referencedim: The total number of features or variables in your dataset.h_dim: The dimensionality of the hidden layer in the GAIN model.cat_columns: A list of indices representing the categorical columns in your dataset.batch_size: The size of mini-batches used during training.hint_rate: The probability of providing hints during training.alpha: A hyperparameter that balances the generator loss and mean squared error loss during training.iterations: The number of training iterations or epochs.
Package: gains
GAINSGAINS - Genetic Algorithm for Identifying Novel Structures - is a project
that enables molecular design and computational screening of
small molecules–in particular solvents–for energy storage applications.Built on the molecular functionality of RDKit, future versions of GAINS
should be employable across a spectrum of small-molecule design problems.To get started using this software, please go to the repositoryREADME.Licensegainsis licensed under the terms of the MIT license. See the file
“LICENSE” for information on the history of this software, terms & conditions
for usage, and a DISCLAIMER OF ALL WARRANTIES.All trademarks referenced herein are property of their respective holders.Copyright (c) 2017–, Wesley Beckner, The University of Washington.
Package: gaitalytics
Python package to extract gait analytic parameters for different kind of recordings (i.e. MOCAP, Force Plate)Free software: MIT licenseInstallationpip install gaitalyticsYou can also install the in-development version with:pip install https://github.com/cereneo-foundation/python-gaitalytics/archive/main.zipDocumentationhttps://python-gaitalytics.readthedocs.orgDevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2024-02-09)First release on PyPI.
Package: gait-gm
Modeling Metabolites as a function of gene expressionGetting StartedA python package gait-gm based on this project is avialable from PyPISeegait-gm on PyPiPrerequisitesSECIMToolsInstallingpip install gait-gmRunning the teststests/galaxy has acceptance tests. Note that some tests can take over 3 hours to run.ContributingForks and contributions are welcome.VersioningWe useCalVerfor versioning. For the versions available, see thetags on this repository.AuthorsAUTHOR:Francisco Huertas-Initial workCONTRIBUTORS:Alison MorseandOleksandr MoskalenkoLicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: gaitmap-mad
Gaitmap-MADThis is a companion package to thegaitmaplibrary.
It contains algorithms developed by theMaD Labin collaboration with industry partners.
Compared to the main gaitmap package, this package is published under a AGPL-3.0 license.To learn more about gaitmap and gaitmap_mad, please visit thegaitmap documentationor thegithub repositoryNote: You should not install this package without gaitmap! Always install the same version of gaitmap and gaitmap_mad.
Package: gait-profile-score
Welcome to Gait Profile Score Calculatorâ€™s documentation!gpscalcis a package that can be used to calculate the gait profile
score as stated in Baker et al. 2009. The package requires the gait
trials kinematic data to be stored in a json file using specific
variable names. (Baker, R. et al., 2009. The Gait Profile Score and
Movement Analysis Profile. Gait and Posture, 30(1), pp. 265-269.)
Kinematic gait data has to be in a specific format for the calculation,
the specifics of the format required can be seen using the functions
below to create example JSON files.How to use the GPS CalculatorPackage Installation::pip install gait-profile-scoreCreate example data in correct format::from gpscalculator import exampleInputData

exampleData = exampleInputData()

# Kinematic variable labels required
labels = exampleData.kinematicVariables()
print(labels)

# Example of a kinematic dataset
dataset = exampleData.kinematics()
print(dataset)

# Save an example of the kinematics JSON file required
exampleData.kinematicsJSON("chosen/directory")Processing the reference group data::from gpscalculator import referenceGroup

# List of paths to the reference group kinematics JSON files
referencePaths = [...]

referenceData = refernceGroup()
referenceData.processGroupData(referencePaths)

# The average of the reference kinematic variables over the gait cycle
referenceKinematics = referenceData.avgKinematics

# The average GPS scores of the reference group relative to the average kinematics
referenceGPS = referenceData.avgRefGPSCalculation of GPS for a single subject::from gpscalculator import calculateGPS

# The kinematic data for the selected subject
subjectKinematics = {kinematic data}

# GPS scores for the subject relative to the reference group average kinematics
subjectGPS = calculateGPS(referenceKinematics, subjectKinematics).gpsPlotting the GPS diagram::from gpscalculator import plotGPS

plot = plotGPS(referenceGPS, subjectGPS, saveplot="test_gps_plot.png")Processessing the GPS scores for a subject group::from gpscalculator import batchGPS

# List of paths to the subject group kinematics JSON files
subjectPaths = [...]

subjectGroup = batchGPS()
subjectGroup.loadReferenceGroup(referencePaths)
subjectGroup.processSubjectGroup(subjectPaths)

# Print the dataframe containing the subject group GPS data
print(subjectGroup.batchData)
Package: gajou
牙城CLIBaseCLI - contains method to send command in terminal with logging. Allure can be passed for adding attaches to
reports.CLIResponse - dataclass for CLI response deserialization.ReturnCodes - enum with basic CLI return codes.HTTPBaseHTTP - contains all basic HTTP methods with logging. Verifies response status and raises one of errors if status
is not 2xx. Allure can be passed for adding attaches to reports.HTTP errors - set of exceptions for typical HTTP error statuses.gRPCBaseInterceptor - adds logging and verifies response status. Allure can be passed for adding attaches to reports.BaseStub - simple wrapper which adds BaseInterceptor to channel.GRPCError - base gRPC exception.DBPostgresHelper - contains all basic commands with logging. Select-command supports simple caching. Can be useful with
any query language like Pypika.DatabaseError - simple DB exception.Singleton - simple implementation of singleton used in DB helper to prevent unnecessary propagation of connections.
Package: gajou-api
牙城-APIHTTPBaseHTTP - contains all basic HTTP methods with logging. Verifies response status and raises one of errors if status
is not 2xx. Allure can be passed for adding attaches to reports.RetrySession - simple implementation of retrying requests for flaky cases.HTTP errors - set of exceptions for typical HTTP error statuses.gRPCBaseInterceptor - adds logging and verifies response status. Allure can be passed for adding attaches to reports.BaseStub - simple wrapper which adds BaseInterceptor to channel.GRPCError - base gRPC exception.
Package: gajula
This is a package comes with general utilities and functionstimeutils functions:****today**: returns today date object or string**

**time** : returns time in given timezone in object or string

**now**: returns local TS in desired format object, string, UNIX

**utcnow**: same as now but in UTC

**tznow**: same as above but given timezone

**str_to_date**: takes string and returns date object

**str_to_time**: takes string and returns time object

**to_datetime**: takes string or UNIX and returns TS object

**to_unix**: takes string or TS object and returns UNIX TS

**change_tz**: takes string or UNIX or TS object and changes to desired timezone
            String -> string
            TS object -> TS object
            UNIX -> UNIX

**second_now**: returns current second in the day

**today_midnight**: returns today midnight TS object

**time_btw**: takes 2 timestamps returns time gap (secs, minutes, hours, days, weeks)

**ts_from_now**:(-past and +future ) takes timestamp and gives next timestamp 
            in given weeks, days, hours, minutes, secs

**weekdays_btw**: takes 2 dates and returns weekday (monday,sunday,3,4) Monday = 0

**weekends_btw**: takes 2 dates and returns weekends in between

**workdays_btw**: takes 2 dates and returns working days between 
**ALL THREE above support string or date object.**

**random_ts**: returns random timestamp in future or past
Package: gak
GAK allows for easy and customizable conversion of numbers to
different bases. Here’s a crash course in usage:from gak import base

# prints "F"
print(base(15, 16))base()takes two arguments: the number being converted, and what
base to convert the number to. An optional third argument is a
custom lookup table for the base conversion that looks as follows:#prints "bab"
print(base(5, 2, {0: "a", 1: "b"}))It is a dictionary where the key is the number to be converted and
the value is what string the number should become. By default GAK
provides a lookup table up to base16.