package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
aglite-test.tabular | AutoML for Image, Text, Time Series, and Tabular DataInstall Instructions| Documentation (Stable|Latest)AutoGluon automates machine learning tasks enabling you to easily achieve strong predictive performance in your applications. With just a few lines of code, you can train and deploy high-accuracy machine learning and deep learning models on image, text, time series, and tabular data.Example# First install package from terminal:# pip install -U pip# pip install -U setuptools wheel# pip install autogluon # autogluon==0.7.0fromautogluon.tabularimportTabularDataset,TabularPredictortrain_data=TabularDataset('https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv')test_data=TabularDataset('https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv')predictor=TabularPredictor(label='class').fit(train_data,time_limit=120)# Fit models for 120sleaderboard=predictor.leaderboard(test_data)AutoGluon TaskQuickstartAPITabularPredictorMultiModalPredictorTimeSeriesPredictorResourcesSee theAutoGluon Websitefordocumentationand instructions on:Installing AutoGluonLearning with tabular dataTips to maximize accuracy(ifbenchmarking, make sure to runfit()with argumentpresets='best_quality').Learning with multimodal data (image, text, etc.)Learning with time series dataRefer to theAutoGluon Roadmapfor details on upcoming features and releases.Scientific PublicationsAutoGluon-Tabular: Robust and Accurate AutoML for Structured Data(Arxiv, 2020)Fast, Accurate, and Simple Models for Tabular Data via Augmented Distillation(NeurIPS, 2020)Multimodal AutoML on Structured Tables with Text Fields(ICML AutoML Workshop, 2021)ArticlesAutoGluon for tabular data: 3 lines of code to achieve top 1% in Kaggle competitions(AWS Open Source Blog, Mar 2020)Accurate image classification in 3 lines of code with AutoGluon(Medium, Feb 2020)AutoGluon overview & example applications(Towards Data Science, Dec 2019)Hands-on TutorialsPractical Automated Machine Learning with Tabular, Text, and Image Data (KDD 2020)Train/Deploy AutoGluon in the CloudAutoGluon-Tabular on AWS MarketplaceAutoGluon-Tabular on Amazon SageMakerAutoGluon Deep Learning ContainersContributing to AutoGluonWe are actively accepting code contributions to the AutoGluon project. If you are interested in contributing to AutoGluon, please read theContributing Guideto get started.Citing AutoGluonIf you use AutoGluon in a scientific publication, please cite the following paper:Erickson, Nick, et al."AutoGluon-Tabular: Robust and Accurate AutoML for Structured Data."arXiv preprint arXiv:2003.06505 (2020).BibTeX entry:@article{agtabular,title={AutoGluon-Tabular: Robust and Accurate AutoML for Structured Data},author={Erickson, Nick and Mueller, Jonas and Shirkov, Alexander and Zhang, Hang and Larroy, Pedro and Li, Mu and Smola, Alexander},journal={arXiv preprint arXiv:2003.06505},year={2020}}If you are using AutoGluon Tabular's model distillation functionality, please cite the following paper:Fakoor, Rasool, et al."Fast, Accurate, and Simple Models for Tabular Data via Augmented Distillation."Advances in Neural Information Processing Systems 33 (2020).BibTeX entry:@article{agtabulardistill,title={Fast, Accurate, and Simple Models for Tabular Data via Augmented Distillation},author={Fakoor, Rasool and Mueller, Jonas W and Erickson, Nick and Chaudhari, Pratik and Smola, Alexander J},journal={Advances in Neural Information Processing Systems},volume={33},year={2020}}If you use AutoGluon's multimodal text+tabular functionality in a scientific publication, please cite the following paper:Shi, Xingjian, et al."Multimodal AutoML on Structured Tables with Text Fields."8th ICML Workshop on Automated Machine Learning (AutoML). 2021.BibTeX entry:@inproceedings{agmultimodaltext,title={Multimodal AutoML on Structured Tables with Text Fields},author={Shi, Xingjian and Mueller, Jonas and Erickson, Nick and Li, Mu and Smola, Alex},booktitle={8th ICML Workshop on Automated Machine Learning (AutoML)},year={2021}}AutoGluon for Hyperparameter OptimizationAutoGluon's state-of-the-art tools for hyperparameter optimization, such as ASHA, Hyperband, Bayesian Optimization and BOHB have moved to the stand-alone packagesyne-tune.To learn more, checkout our paper"Model-based Asynchronous Hyperparameter and Neural Architecture Search"arXiv preprint arXiv:2003.10865 (2020).@article{abohb,title={Model-based Asynchronous Hyperparameter and Neural Architecture Search},author={Klein, Aaron and Tiao, Louis and Lienart, Thibaut and Archambeau, Cedric and Seeger, Matthias},journal={arXiv preprint arXiv:2003.10865},year={2020}}LicenseThis library is licensed under the Apache 2.0 License. |
ag-llama2-api-s | long_description |
ag-llama2-hub-s | long_description |
ag-llama-api | long_description |
ag-llama-api-s | long_description |
ag-llama-hub | long_description |
ag-llama-hub-s | long_description |
agl-model-zoo | agl-model-zooRequirementspytorch
pytorch-lightning
onnx |
agl-ocr-reader | OCR App with APIThe OCR app is an application for extracting text from images and PDF files. It is built on Flask, a Python web framework, and utilizes the Tesseract OCR library and the PIL library for image processing.FeaturesAPI for the upload of images and PDF files for text extraction.
Support for various image formats such as JPG, JPEG, PNG and PDF.
Processing of PDF files by converting them into images and extracting text from the images.
API access to the same texts.RequirementsTo run the app, the dependencies from requirements.txt must be installed:Flask
pytesseract
Tesseract OCR
PIL (Python Imaging Library)
fitz
You can install the dependencies with pip by running the following command:pip install -r requirements.txtStarting the ApplicationRun the app with the following command:python app.pyThe app will be started in test mode onhttp://localhost:5000.API Access GuideFor API usage, a request can be sent for example as Python code with the path of the image in the following form:url = 'http://localhost:5000/api_endpoint'
image_path = '/image_path'
files = {'image': open(image_path, 'rb')}
response = requests.post(url, files=files)Note: Make sure the app is running.InstructionsMake sure the app is running in your webbrowser. Since no content is put on the homepage you will see a server error. To use the API send a request like in the request.py file, supplying your path to the image .NoteMake sure that Tesseract OCR is installed on your system and the 'TESSDATA_PREFIX' environment variable is correctly set to the directory with the Tesseract language data.RechtlichesMedizinische Daten werden mit MedCat klassifiziert.
Die Erstellung erfolgt unter Verwendung der maschinenlesbaren Fassung des Bundesinstituts für Arzneimittel und Medizinprodukte (BfArM).Max Hild // AG Lux // 2023 |
aglog | aglogLogging support tools for pythonDescribe your project here.test3 |
agl-predict-endo-frame | agl-predict-endo-frameLibrary to load the multiclass prediction model and predict frames |
agl-report-reader | agl-report-reader |
aglvq | No description available on PyPI. |
agm | AGM is an unofficial command line interface for Google APIs, written in Python. For example, if I wanted to get a list of all the items in my drive account, I would use the command:[email protected]"*"AGM will parse this command and efficiently execute these requests. AGM works with allGoogle APIsand provides additional features which makes quickly processing data from Google’s APIs simple and easy. It’s great for debugging, G Suite administration, or simple task automation.This tool is currenly inAlpha, so bugs are possible. Please report any issues to theissuestab on GitHub. If you’d like to contribute, please let me know or submit a pull request!Developed and maintained byAlex WennerbergDocumentationMore detailed documentation can be found onreadthedocs! |
agmap | Failed to fetch description. HTTP Status Code: 404 |
agm-dict-validator | No description available on PyPI. |
agm-env-helper | No description available on PyPI. |
agm-io-utils | agm_io_utilsThis package provides some more complex functions e.g. for looking for files and creating unique filenames.Install:pip install agm_io_utilsExample 1:from agm_io_utils import io_utils
p = r"C:\Users\micro\OneDrive\Dokumente"
result_list = io_utils.get_all_files_recursively_from_path(path=p,
file_extensions=[".xmind"],
not_allowed_in_files_name_list=["test", "optional"],
not_allowed_in_path_string_list=["duplicate"],
must_be_a_part_of_files_name_list=["python"])
for file_name in result_list:
print(file_name)Output:2 files found in folder 'C:\Users\micro\OneDrive\Dokumente'
C:\Users\micro\OneDrive\Dokumente\Python.xmind
C:\Users\micro\OneDrive\Dokumente\wmr\Wissen\Python.xmindExample 2:Explanation: Sometimes you get a path to a file through user input. Now the following has to be done:Check whether the file type specified by the user is actually the correct one (e.g. '.txt')Test whether the file actually existsTo save the original file from being changed, find a new file name for the target file.A postfix can either be appended here or, if no postfix is specified, a time stamp is automatically appended. In any case, it must be ensured that the target file does not yet exist in the file system.
If so, count up the file name with an additional index.from agm_io_utils import io_utils
path_to_file = r"C:\Users\micro\OneDrive\Dokumente\clean_this_xminds.txt"
new_filename = io_utils.check_path_and_return_new_file_name_with_postfix(path=path_to_file, extension="txt", postfix="tested")
print(new_filename)Output:C:\Users\micro\OneDrive\Dokumente\clean_this_xminds_tested_06.txt |
agml | 👨🏿💻👩🏽💻🌈🪴 Want to join theAI Institute for Food Systems teamand help lead AgML development? 🪴🌈👩🏼💻👨🏻💻We're looking to hire a postdoc with both Python library development and ML experience. Send your resume and GitHub profile link [email protected]!OverviewAgML is a comprehensive library for agricultural machine learning. Currently, AgML provides
access to a wealth of public agricultural datasets for common agricultural deep learning tasks. In the future, AgML will provide ag-specific ML functionality related to data, training, and evaluation. Here's a conceptual diagram of the overall framework.AgML supports both theTensorFlowandPyTorchmachine learning frameworks.InstallationTo install the latest release of AgML, run the following command:pipinstallagmlQuick StartAgML is designed for easy usage of agricultural data in a variety of formats. You can start off by using theAgMLDataLoaderto
download and load a dataset into a container:importagmlloader=agml.data.AgMLDataLoader('apple_flower_segmentation')You can then use the in-built processing methods to get the loader ready for your training and evaluation pipelines. This includes, but
is not limited to, batching data, shuffling data, splitting data into training, validation, and test sets, and applying transforms.importalbumentationsasA# Batch the dataset into collections of 8 pieces of data:loader.batch(8)# Shuffle the data:loader.shuffle()# Apply transforms to the input images and output annotation masks:loader.mask_to_channel_basis()loader.transform(transform=A.RandomContrast(),dual_transform=A.Compose([A.RandomRotate90()]))# Split the data into train/val/test sets.loader.split(train=0.8,val=0.1,test=0.1)The split datasets can be accessed usingloader.train_data,loader.val_data, andloader.test_data. Any further processing applied to the
main loader will be applied to the split datasets, until the split attributes are accessed, at which point you need to apply processing independently
to each of the loaders. You can also turn toggle processing on and off using theloader.eval(),loader.reset_preprocessing(), andloader.disable_preprocessing()methods.You can visualize data using theagml.vizmodule, which supports multiple different types of visualization for different data types:# Disable processing and batching for the test data:test_ds=loader.test_datatest_ds.batch(None)test_ds.reset_prepreprocessing()# Visualize the image and mask side-by-side:agml.viz.visualize_image_and_mask(test_ds[0])# Visualize the mask overlaid onto the image:agml.viz.visualize_overlaid_masks(test_ds[0])AgML supports both the TensorFlow and PyTorch libraries as backends, and provides functionality to export your loaders to native TensorFlow and PyTorch
formats when you want to use them in a training pipeline. This includes both exporting theAgMLDataLoaderto atf.data.Datasetortorch.utils.data.DataLoader,
but also internally converting data within theAgMLDataLoaderitself, enabling access to its core functionality.# Export the loader as a `tf.data.Dataset`:train_ds=loader.train_data.export_tensorflow()# Convert to PyTorch tensors without exporting.train_ds=loader.train_datatrain_ds.as_torch_dataset()You're now ready to use AgML for training your own models!Public Dataset ListingDatasetTaskNumber of Imagesbean_disease_ugandaImage Classification1295carrot_weeds_germanySemantic Segmentation60plant_seedlings_aarhusImage Classification5539soybean_weed_uav_brazilImage Classification15336sugarcane_damage_usaImage Classification153crop_weeds_greeceImage Classification508sugarbeet_weed_segmentationSemantic Segmentation1931rangeland_weeds_australiaImage Classification17509fruit_detection_worldwideObject Detection565leaf_counting_denmarkImage Classification9372apple_detection_usaObject Detection2290mango_detection_australiaObject Detection1730apple_flower_segmentationSemantic Segmentation148apple_segmentation_minnesotaSemantic Segmentation670rice_seedling_segmentationSemantic Segmentation224plant_village_classificationImage Classification55448autonomous_greenhouse_regressionImage Regression389grape_detection_syntheticdayObject Detection448grape_detection_californiadayObject Detection126grape_detection_californianightObject Detection150guava_disease_pakistanImage Classification306apple_detection_spainObject Detection967apple_detection_drone_brazilObject Detection689plant_doc_classificationImage Classification2598plant_doc_detectionObject Detection2598wheat_head_countingObject Detection6512peachpear_flower_segmentationSemantic Segmentation42red_grapes_and_leaves_segmentationSemantic Segmentation258white_grapes_and_leaves_segmentationSemantic Segmentation273ghai_romaine_detectionObject Detection500ghai_green_cabbage_detectionObject Detection500ghai_iceberg_lettuce_detectionObject Detection500riseholme_strawberry_classification_2021Image Classification3520ghai_broccoli_detectionObject Detection500bean_synthetic_earlygrowth_aerialSemantic Segmentation2500ghai_strawberry_fruit_detectionObject Detection500Usage InformationUsing Public Agricultural DataAgML aims to provide easy access to a range of existing public agricultural datasets The core of AgML's public data pipeline isAgMLDataLoader. You can use theAgMLDataLoaderoragml.data.download_public_dataset()to download
the dataset locally from which point it will be automatically loaded from the disk on future runs.
From this point, the data within the loader can be split into train/val/test sets, batched, have augmentations and transforms
applied, and be converted into a training-ready dataset (including batching, tensor conversion, and image formatting).To see the various ways in which you can use AgML datasets in your training pipelines, check out
theexample notebook.Annotation FormatsA core aim of AgML is to provide datasets in a standardized format, enabling the synthesizing of multiple datasets
into a single training pipeline. To this end, we provide annotations in the following formats:Image Classification: Image-To-Label-NumberObject Detection:COCO JSONSemantic Segmentation: Dense Pixel-WiseContributionsWe welcome contributions! If you would like to contribute a new feature, fix an issue that you've noticed, or even just mention
a bug or feature that you would like to see implemented, please don't hesitate to use theIssuestab to bring it to our attention.
See thecontributing guidelinesfor more information.FundingThis project is partly funded by the [National AI Institute for Food Systems (AIFS)](https://aifs.ucdavis.ed |
agmodeling | AgmodelingStatistical modeling tools, to unify model creation and scoring based on pythonpackage agmodeling.setscoring implements a part of the SET method for comparing
sensor output as described by :An Evaluation Tool Kit of Air Quality 1 Micro-Sensing Units
(Barak Fishbain1,Uri Lerner, Nuria Castell-Balaguer)What’s New(2022/10) correct behavior when DummyRegressor usage (v 0.10)(2022/10) change the way to calculate NRMSE (v 0.9)(2022/09) logging configuration added (v 0.8)(2022/09) introducing get_detailed_score() returning all coef (v 0.7)move to python logger(2022/09) correction of warning after pandas version evolution (v 0.6)(2019/08) python 3 support (v 0.4)(2018/11) First version (v 0.3)DependenciesAgmodeling is written to be use with python 2.7 and python 3.6
It requires Pandas, numpy and scipy
It requiresPandas:pip install pandas
pip install numpy
pip install scipyInstallationspip install agmodelingUses cases |
agms | Agms Python Library for Payment Gateway |
agmsg | UNKNOWN |
agnee | Find sensitive information using dorks from different search-engines.Agnee usessearch_enginesto find sensitive information about given domain using multiple dorks through mutltiple search-engines. I have modified some code ofsearch_enginesand used it in this script to get the custom results and currently it only find results from bing, google and yahoo (will implement more in future for sure).Installationsudopip3installgit+https://github.com/R0X4R/Search-Engines-Scraper.git&&sudopip3installagneeNote: Before installing agnee you must need git and python3 installed on your system.UsageSimple usage arguments$agnee-dtestphp.vulnweb.comhttps://www.exploit-db.com/ghdb/6630https://www.exploit-db.com/ghdb/5665http://testphp.vulnweb.com/secured/phpinfo.phpTo use a specific engine$agnee-dtestphp.vulnweb.com-eyahooYahooDork:inurl:"/.git"testphp.vulnweb.com-githubhttps://www.exploit-db.com/ghdb/6630https://www.exploit-db.com/ghdb/5665http://testphp.vulnweb.com/secured/phpinfo.phpTo search specific number of pages$agnee-dtestphp.vulnweb.com-p1Use all the search-engines$agnee-dtestphp.vulnweb.com-allNote: Sometimes google may block your requests so you need to wait for few hours.DonateIf this tool helped you or you like my workbuymeacoffee.com/R0X4Rpmny.in/bIKNZngt4ys1ko-fi.com/R0X4RWarning:This code was originally created for personal use, do not abuse the traffic, please use with caution. |
agnes | AGNES - Flexible Reinforcement Learning Framework with PyTorchStatus:This framework is under active development and bugs may occur.ResultsMuJoCo(Current results)MuJoCo "Ant-v2" training with 1M steps.Singlerunner withPPOalgorithm,MLPNN and 32 number of envs. The curve is an average of 3 runs.You can get the Tensorboard log file by clicking the image above(You will be redirected to the destination GitHub folder). The default config for the MuJoCo environment was used. Plotted byexamples/plot.pyAtari(Old results)Atari "BreakoutNoFrameskip-v4" with frame stack training with 10M steps.DistributedMPIrunner withPPOalgorithm,LSTMCNNand 16 number of envs.You can get the Tensorboard log file by clicking the image above(You will be redirected to the destination GitHub folder). The default config for the Atari environment was used.Grad-cam technique was used for sampled action chosen by trained LSTMCNN(previous point).RunnersSingleOne worker and trainer.agnes.make_vec_envcan also be used here.importagnesimporttimeif__name__=='__main__':env=agnes.make_env("InvertedDoublePendulum-v2")runner=agnes.Single(env,agnes.PPO,agnes.MLP)runner.log(agnes.log,agnes.TensorboardLogger(".logs/"),agnes.CsvLogger(".logs/"))runner.run()agnes.log- object ofStandardLoggerclass that outputs parameters to console.agnes.TensorboardLogger- class for writing logs in Tensorboard file.agnes.CsvLogger- class for writing logs in csv file. (required for plotting)DistributedMPIUnlike inSinglerunner, inDistributedMPIrunner due to async executing, weights are delayed by one rollout but this has no effect on learning because weights are delayed only by one update as it is inSinglerunner. So all parameters like probabilities ratio stay the same.Runs withmpiexec-n3python-mmpi4pyscript_name.py
or
mpirun-n3python-mmpi4pyscript_name.pyThis command will run 2 workers and 1 trainer.# script_name.pyimportagnesif__name__=='__main__':env=agnes.make_vec_env("BreakoutNoFrameskip-v4")runner=agnes.DistributedMPI(env,agnes.PPO,agnes.CNN)runner.run()AlgorithmsA2CSync version of Advantage Actor Critic is implemented in this framework and can be used simply:importagnesif__name__=='__main__':runner=agnes.Single(env,agnes.A2C,agnes.MLP)runner.run()PPOProximal Policy Optimization is implemented in this framework and can be used simply:importagnesif__name__=='__main__':runner=agnes.Single(env,agnes.PPO,agnes.MLP)runner.run()Neural Network ArchitecturesMulti Layer PerceptronCan be used with both continuous and discrete action spaces....runner=agnes.Single(env,agnes.PPO,agnes.MLP)...Convolutional Neural NetworkCan be used only with discrete action spaces....runner=agnes.Single(env,agnes.PPO,agnes.CNN)...Recurrent Neural NetworkCan be used with both continuous and discrete action spaces....runner=agnes.Single(env,agnes.PPO,agnes.RNN)...Convolutional Recurrent Neural NetworkCan be used only with discrete action spaces....runner=agnes.Single(env,agnes.PPO,agnes.RNNCNN)...Convolutional Neural Network with last LSTM layerCan be used only with discrete action spaces....runner=agnes.Single(env,agnes.PPO,agnes.LSTMCNN)...Make environmentmake_vec_env(env, envs_num=ncpu,config=None)**Parameters:env(str or function) is id of gym environment or function, that returns initialized environmentenvs_num(int) is a number of environments to initialize, by default is a number of logical cores on the CPUconfig(dict) is a dictionary with parameters forMonitorand for initializing environment, by default is None(uses default config)Returns:dict of"env"(VecEnvobject)"env_type"(str)"env_num"(int) is a number of envs inVecEnvobject"env_name"(str) is the name of envs inVecEnvobject(Id in gym or class name)The whole tuple should be put in arunner.make_env(env, config=None)is an alias ofmake_vec_envwithoutenvs_numargument that will be setted to 1.Notice:Some plot functions and environment wrappers were taken fromOpenAI Baselines(2017). |
agnews | Aggregate News ScrapingA simple package to convenience aggregate news scraping through newspaper3k and Google News.Usagefrom agnews.scraper import scrape_ag, parse_ag
query = "YOUR QUERY HERE"
path = "PATH TO DATAFRAME HERE"
scrape_ag(query, path)
parse_ag(path)Credits: Darshan Khandelwal, newspaper3k |
agni | agniAGNI (AutoGrader with Nice Interface), a Python assignment grading tool and a companion to Codepost. Less test-case boilerplate; execute in Singularity containers; test results in HTML. |
agnishwarsHelloWorldPackage | No description available on PyPI. |
agnm | Physics equations of motion solverThis is a package for physics motion calculations.Installationpip install agnmUsageDisplacementDisplacement is calculated using formula:x = (vi-vf)/2*tfromagnm.motionimportdisplacementdisplacement(1,2.3,3)# output: 2.65# or use named variablesdisplacement(vf=2.3,t=1,vi=3)# output: 2.65Change in positionChange in position is calculated using formula:x = vi*t+1/2*a*t^2fromagnm.motionimportchange_in_positionchange_in_position(1,3,2)# output: 12.0# or use named variableschange_in_position(a=2,t=3,vi=1)# output: 12.0Final velocityFinal velocity is calculated using one of formulas:vf = (vi^2+2a*x)^1/2
vf = vi+a*tfromagnm.motionimportv_final# using first equationv_final(vi=1,a=3,x_delta=1.5)# output: 10.0# using second equationv_final(vi=1,a=2.3,t=2)# output: 5.6Average velocityAverage velocity is calculated using one of formulas:va = x/t
va = (vi+vf)/2fromagnm.motionimportv_average# using first equationv_average(x_delta=1,t=3)#output: 0.3333333333333333# using second equationv_average(vi=1,vf=2.6)#output: 0.8AccelerationAcceleration velocity is calculated using one of formulas:a = v/t
a = (vf+vi)/tfromagnm.motionimportacceleration# using first equationacceleration(v_delta=5,t=2.5)#output: 2.0# using second equationacceleration(vi=1,vf=6,t=2.5)#output: 2.0 |
agnmo | Physics equations of motion solverThis is a package for physics motion calculations.Installationpip install agnmolUsageDisplacementDisplacement is calculated using formula:x = (vi-vf)/2*tfromagnm.motionimportdisplacementdisplacement(1,2.3,3)# output: 2.65# or use named variablesdisplacement(vf=2.3,t=1,vi=3)# output: 2.65Change in positionChange in position is calculated using formula:x = vi*t+1/2*a*t^2fromagnm.motionimportchange_in_positionchange_in_position(1,3,2)# output: 12.0# or use named variableschange_in_position(a=2,t=3,vi=1)# output: 12.0Final velocityFinal velocity is calculated using one of formulas:vf = (vi^2+2a*x)^1/2
vf = vi+a*tfromagnm.motionimportv_final# using first equationv_final(vi=1,a=3,x_delta=1.5)# output: 10.0# using second equationv_final(vi=1,a=2.3,t=2)# output: 5.6Average velocityAverage velocity is calculated using one of formulas:va = x/t
va = (vi+vf)/2fromagnm.motionimportv_average# using first equationv_average(x_delta=1,t=3)#output: 0.3333333333333333# using second equationv_average(vi=1,vf=2.6)#output: 0.8AccelerationAcceleration velocity is calculated using one of formulas:a = v/t
a = (vf+vi)/tfromagnm.motionimportacceleration# using first equationacceleration(v_delta=5,t=2.5)#output: 2.0# using second equationacceleration(vi=1,vf=6,t=2.5)#output: 2.0 |
agnos | Agnosis across-language,cross-platform, lightweight RPC framework
with support for passing objectsby-valueorby-reference. Agnos is meant
to allow programs written in different languages to easily interoperate,
by providing the needed bindings (glue-code) and hiding all the details from
the programmer. The project essentially servers the same purpose as existing
technologies likeSOAP,WSDL,CORBA, and others, but takes aminimalist approachto the issue at hand. |
agnos_compiler | Agnosis across-language,cross-platform, lightweight RPC framework
with support for passing objectsby-valueorby-reference. Agnos is meant
to allow programs written in different languages to easily interoperate,
by providing the needed bindings (glue-code) and hiding all the details from
the programmer. The project essentially servers the same purpose as existing
technologies likeSOAP,WSDL,CORBA, and others, but takes aminimalist approachto the issue at hand. |
agnostic | Agnostic Database MigrationsOverviewAgnostic is a light-weight, easy-to-learn, and flexible database migration tool
in which migration scripts are written in pure SQL. It is agnostic towards
database, programming language, and object relational mapper (ORM).Super Quick StartHere is an absurdly brief introduction to Agnostic:~/myapp$mkdirmigrations
~/myapp$agnostic-tpostgres-umyuser-dmydbbootstrap
Migrationtablecreated.
~/myapp$cat>migrations/add_cell_phone.sql
ALTERTABLEcustomerADDcell_phoneVARCHAR(255);^D
~/myapp$cat>migrations/add_nickname.sql
ALTERTABLEcustomerADDnicknameVARCHAR(255);^D
~/myapp$agnostic-tpostgres-umyuser-dmydbmigrate
Backingup"mydb"to"/tmp/tmpm8glpgaa".
Abouttorun2migrationsin"mydb":*Runningmigrationadd_cell_phone(1/2)*Runningmigrationadd_nickname(2/2)Migrationscompletedsuccessfully.
Removingbackup"/tmp/tmpm8glpgaa".For a not-quite-as-quick-but-still-pretty-quick start, please refer to thefull documentation. |
agnostica | Agnostica is a platform-agnostic library to make the creation of chat bots that function on multiple platforms more simple and streamlined.DocumentationDocumentation is currently a work in progress.SupportThere is currently not yet a support server for the library. |
agnostic-calculator | Agnostic CalculatorA Python3 library that parses strings representing mathematical expressions. TheCalculatortakes aconverterby which means you can specify numerical types other than regular base 10 numbers. There is one converter available:roman.How to installUsing pip:pip install agnostic-calculatorManually:git clone [email protected]:carawarner/calculator.git
cd calculator/calculator
virtualenv -p python3 venv
source venv/bin/activate
pip install -r requirements.txtHow to run testsThis libary usespytest, a powerful but lightweight testing tool for Python.cd calculator
pytestHow to useWARNING: Don't useagnostic-calculatorin production. The calculator library calls Python'seval()on user input.It's not safe.fromcalculator.calculatorimportCalculatorimportcalculator.converters.romanasconvertercalculator=Calculator(converter)result=calculator.evaluate(expression) |
agnostic-file-store | AFS - Agnostic File StorageGoals and motivationsThe purpose of this module is to offer an agnostic, easy-to-use module
for different file systems (At present time, just local and SMB/CIFS).
The initial use of this module was provide an easy path to translate
local file systems operations to a network samba server.Example of useSo, you can translate code like this:if os.path.isdir('/tmp/token.txt'):
if not os.path.isdir('/tmp/results'):
os.mkdir('/tmp/results')
with open('/tmp/results/data.txt', 'wb') as f:
f.write('This is an example\n')To something like this (which must work identical):with afs.connect('temp') as fs:
if not fs.isdir('results'):
fs.mkdir('results')
fs.cd('results')
fs.save('data.txt', 'This is an example\n')Usually you need to iterate a list of directories checking
for the existence of the dir, create if needed, and then changing
to the dir, for every directory::dirs = ['media', 'public', '2016', 'sep', '14']
with afs.connect('static') as fs:
for dir in dirs:
if not fs.is_dir(dir):
fs.mkdir(dir)
fs.cd(dir)
# You can save the file nowUsing theset_pathmethod make all this steps with one single call::with afs.connect('static') as fs:
fs.set_path('media', 'public', '2016', 'sep', '14')
# You can save the file nowThe entrytempis defined in a configuration file, using
a format similar to windows .INI files, like this:[temp]
kind: local
base: /tmpWe can now switch to another directory by just replacing thetempbase entry to the desired base path, for example. More
interesting, you can change to a network SMB Server, modifying the
configuration file to:[temp]
kind: smb
username: samba_user
password: samba_password
host: nas
domain: mycompany.com
service: test$Things to doAdd more storage file systems: NFS, Amazon S3, SFTPImprove security, nobody likes password stored as plain text
in configuration files.More tests |
agnostic-loader | No description available on PyPI. |
agno-storage | cloud-agnostic-storagescloud agnostic storages |
agn_periodics | UNKNOWN |
agnpy | agnpyModelling Active Galactic Nuclei radiative processes with python.descritpionagnpyfocuses on the numerical computation of the photon spectra produced by leptonic radiative processes in jetted Active Galactic Nuclei (AGN).agnpy binderRun this repository in binderacknowledging and citing agnpyAs a general acknowledgement ofagnpyusage, we recommend citing the agnpy release paper.
Additionaly, to specify which version ofagnpyis being used, that version's zenodo record can be cited.
We recommend citing both.At the following links you can find:the agnpy release paper (for a general citation);the zenodo record (for citing a specific version)documentation and quickstartYou are invited to check the documentation athttps://agnpy.readthedocs.io/en/latest/.To get familiar with the code you can run the notebooks in thetutorialssection
of the documentation.dependenciesThe only dependencies are:numpymanaging the numerical computation;astropymanaging physical units and astronomical distances.matplotlibfor visualisation and reproduction of the tutorials.scipyfor interpolationinstallationThe code is available in thepython package indexand can be installed viapippipinstallagnpyThe code can also be installed usingcondacondainstall-cconda-forgeagnpytestsA test suite is available inagnpy/tests, to run it just typepytestin the main directory.shields |
ago | What are human readable timedeltas?ago.py makes customizable human readable timedeltas, for example:Testing past tense:Russell commented 1 year, 127 days, 16 hours ago
You replied 1 year, 127 days agoTesting future tense:Program will shutdown in 2 days, 3 hours, 27 minutes
Job will run 2 days, 3 hours from nowHow to installThere are a number of ways to install this package.You could run this ad hoc command:pip install agoor specifyagounder thesetup_requireslist within yoursetuptools-compatible project’ssetup.pyfile.How to useThe ago module comes with three functions:humandelta2dictget_delta_from_subjectYou really only need to worry abouthuman.Here are all the available arguments and defaults:human(subject, precision=2, past_tense='{} ago', future_tense='in {}', abbreviate=False):subjecta datetime, timedelta, or timestamp (integer/float) object to become human readableprecision (default 2):the desired amount of unit precisionpast_tense (default ‘{} ago’):the format string used for a past timedeltafuture_tense (default ‘in {}’):the format string used for a future timedeltaabbreviate (default False):boolean to abbreviate unitsHere is an example on how to usehuman:from ago import human
from ago import delta2dict
from datetime import datetime
from datetime import timedelta
# pretend this was stored in database
db_date = datetime(year=2010, month=5, day=4, hour=6, minute=54, second=33, microsecond=4000)
# to find out how long ago, use the human function
print 'Created ' + human( db_date )
# optionally pass a precision
print 'Created ' + human( db_date, 3 )
print 'Created ' + human( db_date, 6 )We also support future dates and times:PRESENT = datetime.now()
PAST = PRESENT - timedelta( 492, 58711, 45 ) # days, secs, ms
FUTURE = PRESENT + timedelta( 2, 12447, 963 ) # days, secs, ms
print human( FUTURE )Example past_tense and future_tense keyword arguments:output1 = human( PAST,
past_tense = 'titanic sunk {0} ago',
future_tense = 'titanic will sink in {0} from now'
)
output2 = human( FUTURE,
past_tense = 'titanic sunk {0} ago',
future_tense = 'titanic will sink in {0} from now'
)
print output1
# titanic sunk 1 year, 127 days ago
print output2
# titanic will sink in 2 days, 3 hours from nowNeed more examples?You should look at test_ago.pyHow do I thank you?You should follow me on twitterhttp://twitter.com/russellbalLicensePublic DomainPublic Revision Controlhttps://git.unturf.com/python/ago |
agodashi | AgodashiAgodashi is a simple REST API server.
It takes a workflow file written in workflow language as input and returns workflow type, workflow version and workflow parameters template.
Currently, supported workflow languages are as follows:Common Workflow Language (CWL)In the future, we plan to support the following languages.NextflowSnakemakeWorkflow Description Language (WDL)Install and RunAgodashi supports Python 3.6 or newer.$pip3installagodashi
$agodashiDockerWe also expect to launch using Docker.# Launch$docker-composeup-d# Launch confirmation$docker-composelogsUsageAs API specifications, please checkSwaggerUI - Agodashi API SpecThe help for the Agodashi startup command is as follows.$agodashi--help
usage:agodashi[-h][--host][-p][--debug]AnAPIserverforparsingworkflowswritteninworkflowlanguages
optionalarguments:-h,--helpshowthishelpmessageandexit--hostHostaddressofFlask.(default:127.0.0.1)-p,--portPortofFlask.(default:8080)--debugEnabledebugmodeofFlask.As the simplest example of a REST API Request, here is the result of aPOST /inspect-workflow.POST/inspect-workflow-F'wf_url=https://raw.githubusercontent.com/suecharo/agodashi/master/tests/resources/cwl/trimming_and_qc_packed.cwl'{"wf_params":"nthreads: 2 # default value of type \"int\". (optional)\nfastq_2: # type \"File\"\n class: File\n path: a/file/path\nfastq_1: # type \"File\"\n class: File\n path: a/file/path\n","wf_type":"CWL","wf_version":"v1.0"}DevelopmentYou can start the development environment as follows.$docker-compose-fdocker-compose.dev.ymlup-d--build
$docker-compose-fdocker-compose.dev.ymlexecappbashWe useflake8,isort, andmypyas the Linter.$bash./tests/lint_and_style_check/flake8.sh
$bash./tests/lint_and_style_check/isort.sh
$bash./tests/lint_and_style_check/mypy.shWe usepytestas a Test Tool.$pytest.LicenseApache-2.0. See theLICENSE. |
agodzoYTRenderer | # agodzoYTRenderer is a python package that allows you to render Youtube videos in your Jupyter Notebook.
# Example Code:` from agodzoYTRenderer import render_YouTube_video `` URL =https://www.youtube.com/watch?v=4HOs2cApb90render_Youtube_video(URL) ` |
agoge | AgogeAn opinionated ML development environmentTrain pytorch models, hyperparameter tune them with single loc change.LibrariesPytorchPytorchis a Python first machine learning libraryRayRayProvides easy experiment scaling + hyper parameter optimisationWeights and BiasesAgoge uses WandB to monitor model training. It's super easy to setup, just go to thewandb websiteand sign up for an account. Then follow the instructions to set upStatic ComponentsThese components should not need to be customised for model specific use casesTrain WorkerSetups all the required components to train a modelInference WorkerSetups all the required components for inference. Also attempts to download model weights if they are not found locally.Data HandlerLoads the dataset and handles the dataset splitUser Provided ComponentsThese components need to be inherited by project specific classesModelProvides some convenience functions around loading models. This class will hold all model specific code and is used by the train worker and inference workersSolverOverride thesolvemethod with the code required to train your modelDatasetAny dataset that is compatiable with thePytorch map style dataset modelDisclaimerThis code is subject to change. I will try not to break anything but can't promise. File an issue if an update breaks your code |
agogos | The Agogos package contains implementations of ml pipeline blocks and the underlying codeThis package contains many modules and classes necessary to construct the ml pipeline for machine learning competitions.Pytest coverage reportTo generate pytest coverage report runpytest--cov=agogos--cov-report=html:coverage_reDocumentationDocumentation is generated usingSphinx.To make the documentation, runmake htmlwithdocsas the working directory. The documentation can then be found indocs/_build/html/index.html.Here's a short command to make the documentation and open it in the browser:cd./docs/;./make.bathtml;startchromefile://$PWD/_build/html/index.htmlcd../Uploading to pypipython-mbuild |
agogosml | This project includes the library for Agogosml. Please refer to the overall documentation:User Guide - Getting StartedDeveloper GuideHistory0.1.0 (2018-11-06)First release on PyPI. |
agogosml-cli | This project includes the CLI for Agogosml. Please refer to the overall documentation:User Guide - Getting StartedDeveloper GuideHistory0.1.0First release on PyPI. |
agokufastapi | 个人封装的库 |
agon | AgonAgon is a thin wrapper aroundjmespathwhich let you to compose projections in a more natural manner.It's usage is quite simplefromagonimportAgonassertAgon("foo | bar")==Agon("foo")|Agon("bar")==Agon("foo")|"bar"assert{"foo":{"bar":"baz"}}|Agon("foo | bar")=="baz"assert{"foo":{"bar":"baz"}}|Agon("foo")|Agon("bar")=="baz"assert{"foo":{"bar":"baz"}}|(Agon("foo")|"bar")=="baz" |
agon-ratings | Provides user ratings of objects.DocumentationDocumentation can be found online athttp://agon-ratings.readthedocs.org/. |
agora | No description available on PyPI. |
agora-api | Agora APIThe collection of APIs and models that can be used to interact with the Agora services. |
agora-api-internal | Agora APIThe collection of APIs and models that can be used to interact with the Agora services. |
agora-busclient | agora_busclientThis package is the Bus Client library for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv 1.1.51Fix for BREAKING change for paho.mqtt.pythonv2.0.0 Added callback_api_version=mqtt.CallbackAPIVersion.VERSION1 as the first argument to Client()v 1.1.50Fix Event Message Schema with MediaDataRef & Workflow types naming conventionv 1.0.47Fix bug in getting port number and update tests in baseline.v 1.0.46Fix bug in decoding/encoding of events which left out SlaveIdv1.0.18Make versions of all modules all the sameAdd ability to Mock (AEA2:BusClient:Mock (True/False)) the BusClientFix issue with subscriptionsv1.0.8 - BetaAdd ability to change the message topic for send_data and send_request.v1.0.7 - BetaInitial test release. |
agora-cli | No description available on PyPI. |
agora-community-sdk | No description available on PyPI. |
agora-config | agora_configThis package is the Configuration library for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.26Deprecate config_overrides and config_defaults in favor or config.overrides and config.defaults to make more parallel to .NET SDK. Update all associated documentation.v1.0.23Remove config default value "DEVICE_ID"Set default config value "GATEWAY_ID" to be "IOTEDGE_DEVICEID" env var if it is available.Set default config value "Name" to be "IOTEDGE_MODULEID" env var if it is available.Set default config value "GROUP_ID" to be "GROUP_ID" env var if it is available.v1.0.20Redo DictOfDict. Remove 'DictOfDict.remove' in favor of having 'del' capability supported.Support ability to get a super setting from config and still address sub-settings using 'key:key' nomenclature.Update internal testsv1.0.19Fix issue with return of dictionary from config for "partial" paths to keys.v1.0.18Make versions of all modules all the samev1.0.15 - BetaChange AEA2:Logging:Verbosity setting to AEA2:LoggingFix issue in config change callback (simplify code) - reduce to a single thread for maintainabilityv1.0.7 - BetaInitial test release. |
agora-cpplint | cpplint - static code checker for C++Cpplint is a command-line tool to check C/C++ files for style issues followingGoogle’s C++ style guide.
Cpplint is developed and maintained by Google Inc. atgoogle/styleguide, also see thewikipedia entryWhile Google maintains cpplint, Google is not (very) responsive to issues and pull requests, this fork aims to be (somewhat) more open to add fixes to cpplint to enable fixes, when those fixes make cpplint usable in wider contexts.
Also see discussion herehttps://github.com/google/styleguide/pull/528.InstallationTo install cpplint from PyPI, run:$pipinstallcpplintThen run it with:$cpplint[OPTIONS]filesFor full usage instructions, run:$cpplint--helpChangesThe modifications in this fork are minor fixes and cosmetic changes, such as:python 3 compatibilitymore default file extensionscustomizable file extensions with the –extensions argumentcontinuous integration on githubsupport for recursive file discovery via the –recursive argumentsupport for excluding files via –excludeJUnit XML output formatOverriding repository root auto-detection via –repositorySupport#pragma onceas an alternative to header include guards… and a few more (most of which are open PRs on upstream)AcknowledgementsThanks to Google Inc. for open-sourcing their in-house tool.
Thanks to maintainers of the forktkrusemattyclarksontheandrewdavis |
agora-demo | No description available on PyPI. |
agoradesk-py | agoradesk_pyPython interface forAgoraDesk.com/LocalMonero.co API.This is currently not a complete implementation of the Agoradesk API.The following API calls are currentlynotsupported.Image uploading in chatI offer no warranty of any kind -- use this at your own risk!I am not associated with AgoraDesk.com or LocalMonero.co.Requirements:The two main requirements arehttpxandarrow.
I am usingPoetrywith this project to keep track of dependencies / requirements.Installpip install agoradesk_pyHow to UseThis is an example about how you can use the library#!/usr/bin/env python3
from agoradesk_py.agoradesk import AgoraDesk
api_key = <YourAPIKey>
api = AgoraDesk(api_key)
# Get information about all released trades
api_response = api.dashboard_released()
if api_response["success"]:
trades = api_response["response"]["data"]["contact_list"]
for trade in trades:
trade_data = trade["data"]
print(
f"Traded "
f"{trade_data['amount_xmr']} XMR with a fee of {trade_data['fee_xmr']} XMR "
f"for {trade_data['amount']} {trade_data['currency']} "
f"on {trade_data['released_at']}"
)
else:
print(f"Error: {api_response['response']['error']}")Running TestsPlease be aware of the unauthenticated API requests limit of 20 req/hTests are split into Unit tests and integration tests.To prepare to run any tests:Clone this repository to your computer.InstallPoetryInstall all dependencies / requirements for agoradesk_py using the commandpoetry installin the project directory.Unit TestsUnit tests do not communicate with LocalMonero / AgoraDesk and are executed entirely locally.Running all unit tests with coverage report is as easy as using the commandpoetry run pytest --cov-report term-missing tests/unit/in the project directory,Integration TestsIntegration tests communicate with the actual LocalMonero / AgoraDesk production APIs and the tests depend on
the two following environment variables being set to the api_keys of two testing accounts at LocalMonero.co.api_keyapi_key2Please be aware that:LocalMonero.co or AgoraDesk.com are not currently providing a testing setup and all testes are running in their production environment.For some tests to run successfully the account forapi_key2needs to have a balance of currently about 0.1 XMRThe two testing account need to be set to trust each other for all the tests to be successful.To run the integration tests use the commandpoetry run pytest tests/integration/ContributeDo you have an idea or found a bug in agoradesk_py? Please file an issue and/or submit a pull request! :)Source code is currently onCodebergathttps://codeberg.org/MarvinsCryptoTools/agoradesk_pySupportIf you like the API and want to support me you can do so with
Monero:
88NszkQU9qsafT9obFaDZSi7RvHSM76exJ1vvgVShTwM4HjvLr7XjJ7jDkFGnxr3UsDXLgT5t569N6uB7Gn4znjAFjUuN1q |
agorae | fc742dd906f487180b5646cd08b059e2b3f82620e1eb97a47a9e7b58c143d0e0 |
agora-graphql | No description available on PyPI. |
agora-gw | No description available on PyPI. |
agoraiot | agoraiotThis primary package for the entire Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.18Make versions of all modules the samev1.0.7 - BetaInitial test release. |
agora-logging | agora_loggingThis package is the Logging library for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.20Fix message about Verbosity instead of LogLevelForce flush of sys.stdout when writing exception logsv1.0.18Make versions of all modules all the samev1.0.7 - BetaInitial test release. |
agoraplex.themes.sphinx | This repository containsSphinxthemes forAgoraplexprojects,
based on thePylons Sphinx Themes, and some helper roles. The
following themes exist:agoraplex- the genericAgoraplexdocumentation themeRequirementsSphinx1.1 or newerTo rebuild the graphics from the SVG originals (which requires cloning
thegithub repository):rsvg-convertfromlibrsvgpngtopam,pnmremap,pnmcolormap, andpnmtopngfromNetpbmicotoolfromicoutilsInstallationTo use a theme in your Sphinx documentation, follow this guide:Install the package:$ pip install agoraplex.themes.sphinxEdit yourconf.pydoc configuration file to point to theagoraplextheme:import agoraplex.themes.sphinx
# ...
html_theme = 'agoraplex'
html_theme_path = agoraplex.themes.sphinx.get_html_theme_path()HelpersThis package adds several Sphinx helper roles (inroles.py). To
use these, addagoraplex.themes.sphinx.rolesto theextensionslist in yourconf.py.The roles are:github: link to agithubproject::github:`agoraplex/themes`Thegithub_urlconfiguration directive defaults tohttps://github.com/.pypi: link to a project record atPyPi, the Python Package
Index::pypi:`agoraplex.themes.sphinx`Thepypi_urlconfiguration directive defaults tohttp://pypi.python.org/pypi/wikipedia: link to aWikipediaarticle::wikipedia:`Ancient Agora of Athens`Thewikipedia_urlandwikipedia_langconfiguration
directives default tohttp://%s.wikipedia.org/wiki/anden, respectively. Note that thewikipedia_urldirectivemustcontain a%s, where the role will insert thewikipedia_langvalue.Thewikipediarole will (mostly) canonicalize an article
name by replacing spaces with underscores (_), uppercasing
the first letter of the name, and lowercasing the
rest. Wikipedia’s own URL rewriting is tolerant of case
mismatch, so these simplistic rules work well enough.ConfigurationIn addition to the role-related configuration directives, this theme
adds the following directives to the set defined by the original
Pylons theme:fontsets: a space-separated list of directory names, relative to
thefont directory(_static/fonts), from which to load astylesheet.cssfile [email protected]_body,font_header: the ‘base’ names of the fonts to use
for body and header text, respectively.NoteThe stylesheets assume that the font family is actually named<fontname>Regular. So, to useNeutonRegularas the header
font (which is the default),theme.confwould specifyfont_header=Neuton. |
agora-py | No description available on PyPI. |
agora-python-sdk | Agora Python SDKAgora Live Interactive Video Streaming enables one-to-many and many-to-many audio or video live streaming with the Agora RTC SDK.Agora Live Interactive Video Streaming is different fromAgora Video Call. In a video call, all users are the same role and can talk to each other freely. In a live video streaming, users can be the host or audience, where only the host can talk. For details, see thisFAQ.Different from the traditional CDN live broadcast, which only allows one-way communication from the hosts to the audience, the Agora RTC SDK empowers the audience to interact with the hosts by [becoming a host](https://docs.agora.io/en/AgoraPlatform/terms?platform=All Platforms#becoming-host), like a viewer jumping onto the stage in the middle of a play to perform.The Agora RTC SDK is applicable to scenarios that encourage active engagement, such as game-playing, online classes for students in small groups, and Q&A sessions during E-commerce live streaming. You can also use this SDK for one-to-one video calls that require high image quality.For more detail information, please visit ourwebsiteandGitHub repository; and for some quick-start demos, please visitAgora-Python-QuickStart. |
agora-redis-client | agora_redisclientThis package is the Redis Client for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.26Initial Version of Redis Client |
agoras | A command line python utility to manage your social networks (Twitter, Facebook, LinkedIn and Instagram)Current version: 1.1.3Agoras is a python utility that helps publish and delete posts on the most
popular social networks (twitter, facebook, instagram and linkedin).This repository stores the application. There’s alsoGitHub actionsthat you can incorporate into your workflows.For more information, please read thefull documentation. |
agora-signaling-sdk | Agora.io Signal Python SDK==========================This is a wrapper of Agora signal APIs thats enables developers integrate Agora's signal service within 30 minutes.Quick start example:.. code-block:: python>>> from agorasigsdk.agora_signal import AgoraSgnal>>> from twisted.internet import reactor>>> appid = 'THIS_IS_YOUR_APPID.'>>> ag_sig = AgoraSignal(appid)>>> session = ag_sig.login('ACCOUNT_NAME', 'TOKEN', CALLBACK_CLASS_INSTANCE)>>> reactor.run()Now you have a logged in Agora Signaling Session!Installation------------.. code-block:: bashpip install agora-signaling-sdkEasy and ready to go.Documentation-------------Please find in https://docs.agora.io |
agora-token-builder | Agora Token GeneratorDescriptionToken generator for building a token server with Python & the Agora RTM/RTCInstallationpip install agora-token-builderUsageRTC Live Video Calling & Chat SDKBuild token withintUID:fromagora_token_builderimportRtcTokenBuilder#Build token with uidtoken=RtcTokenBuilder.buildTokenWithUid(appId,appCertificate,channelName,uid,role,privilegeExpiredTs)Build token withstringUserAccount:fromagora_token_builderimportRtcTokenBuilder#Build token with userAccounttoken=RtcTokenBuilder.buildTokenWithAccount(appId,appCertificate,channelName,account,role,privilegeExpiredTs)RTM Real-Time Messaging & Chat SDKBuild RTM token.fromagora_token_builderimportRtmTokenBuildertoken=RtmTokenBuilder.buildToken(appID,appCertificate,userAccount,role,privilegeExpiredTs)Variable DefinitionsappIDThe App ID issued to you by Agora. Apply for a new App ID from the gora Dashboard if it is missing from your kit. See Get an App ID.appCertificateCertificate of the application that you registered in the Agora Dashboard. See Get an App Certificate.channelNameUnique channel name for the AgoraRTC session in the string formatuidUser ID. A 32-bit unsigned integer with a value ranging from 1 to (232-1). optionalUid must be unique.userAccountA unique identifier used for to represent a user account. This value will be a string and can contain numbers, letters and any special characters.roleRole_Publisher = 1: A broadcaster (host) in a live-broadcast profile. Role_Subscriber = 2: (Default) A audience in a live-broadcast profile.privilegeExpireTsRepresented by the number of seconds elapsed since 1/1/1970. If, for example, you want to access the Agora Service within 10 minutes after the token is generated, set expireTimestamp as the currentLicense© 2021 Agora.ioThis repository is licensed under the MIT license. See LICENSE for details. |
agora-token-server | No description available on PyPI. |
agora-twin-property | agora_twin_propertyThis package is the twin property library for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.46 - BetaInitial test release. |
agora-utils | agora_utilsThis package is the Utilities library for the Agora Edge Apps SDK (Python) developed by SLB.Use this SDK to construct an edge application, and then containerize it for the running on the edge with AgoraIoT. Documentation on using the entire SDK can be found at:AgoraIoT SDK Documentation.Release Notesv1.0.18Make versions of all modules all the sameAdd ability to Mock (AEA2:BusClient:Mock (True/False)) the BusClientFix issue with subscriptionsv1.0.7 - BetaInitial test release. |
agora-wot | No description available on PyPI. |
agottani-distributions | No description available on PyPI. |
agox | Atomistic Global Optimization X (AGOX)AGOX is a package for global optimization of atomic system using e.g. the energy
calculated from density functional theory as the objective function. AGOX interfaces
with the Atomistic Simulation Environment (ASE) and as such supports any of
calculators in ASE as objectives for optimization.AGOX is built to be flexible, consisting of modules that can be put together to
create an optimization algorithm, from simple random searches to Bayesian searches
guided by a surrogate model and many more.Check out the documentation athttps://agox.gitlab.io/agox/Contributions & IssuesFeel free to make a fork and submit a merge request!If you have an issue or a question please post it on the issue board!AuthorsThe main AGOX framework has been written byMads-Peter Verner ChristiansenNikolaj RønneBjørk Hammerwith inspiration and help from current and previous members of the Hammer group at Aarhus University, Denmark.
Parts of the code have been contributed byAndreas Slavensky (Complementary Energy Generator)LicenseAGOX is released under the GPLv3 license. |
agp | Package containing entrypoint.py from entrypoint code and environment.py for drone-specific environment code. This allows for transformers to havecommon entrypoint and environment code in an installable package |
agp87_print_list | UNKNOWN |
agpdf | This is the homepage of our project. |
agp-py | Axie Gene Parser for PythonWIP - haven't ported all the stuff the other module has (Mostly because I only find the genes useful)This is a port of the Javascript version of a plugin, you can find it here:agp-npmIt parses the Axie Infinity hexadecimal gene strings into a human-readable format.InstallYou can use pip to install:pipinstallagp-pyUsageFirst you need to get an Axie Gene String (You can useAxie Infinity GraphQL), after that you can start:We will be using0x30000000032cb3300c2320c80c2308c20c63184c04c1304c0c6331420c8320c8as our hex string.fromagp_pyimportAxieGenehex_string='0x30000000032cb3300c2320c80c2308c20c63184c04c1304c0c6331420c8320c8'hex_type=256gene=AxieGene(hex_string,hex_type)print(gene.genes)TheAxieGeneclass requires 2 arguments, First one is the hex string, Second one is the hex type (Either 256 or 512)Then you can access the genes by using the methodgenes, it will give you a dictionary with the gene data.{'cls':'plant','region':'global','tag':'','bodySkin':'','pattern':{'d':'000011','r1':'001011','r2':'001011'},'color':{'d':'efd636','r1':'efd636','r2':'ffffff'},'eyes':{'d':{'class':'plant','name':'Papi','partId':'eyes-papi','specialGenes':'','type':'eyes'},'r1':{'class':'plant','name':'Cucumber Slice','partId':'eyes-cucumber-slice','specialGenes':'','type':'eyes'},'r2':{'class':'plant','name':'Cucumber Slice','partId':'eyes-cucumber-slice','specialGenes':'','type':'eyes'},'mystic':False},# Other parts ....} |
agprefstojson | No description available on PyPI. |
agps3 | READMEThis package is based on a fork of gps3 (https://github.com/wadda/gps3) which hasn't been updated in a while.It includes some bug fixes for GST class handling.
Only agps versions exist in this package.To use:from agps3threaded import AGPS3mechanismThen engage the thread triumvirate,agps_thread = AGPS3mechanism() # This instantiate the mechanism, as I believe it's called.
agps_thread.stream_data() # Stream the data from host, port, devicepath.
agps_thread.run_thread() # Iterate stream as a thread with throttle control for empty look ups.Four lines of code that lets you connect, communicate and control most of what you expect a gpsd to do.while True: # All data is available via instantiated thread data_stream attributes. Confur# lines #140-ff of the client /usr/local/lib/python3.5/dist-packages/gps3/agps.py
print('----------------')
print( agps_thread.data_stream.time)
print('Lat:{} '.format(agps_thread.data_stream.lat))
print('Lon:{} '.format(agps_thread.data_stream.lon))
print('Speed:{} '.format(agps_thread.data_stream.speed))
print('Course:{}'.format(agps_thread.data_stream.track))
print('----------------')
sleep(60) # Sleep, or do other things for as long as you like.Without arguments between the parentheses, the threaded client defaults tohost='127.0.01',port=2947,gpsd_protocol='json', andusnap=0.2, for a respectable default of 2/10th of a second micro nap after each empty socket lookup.The rest of the project is inDESCRIPTION.rst, or documented in the files themselves. |
agpt | Auto-GPT: An Autonomous GPT-4 Experiment💡 Get help -Q&AorDiscord 💬🔴 🔴 🔴 Urgent: USEstablenotmaster🔴 🔴 🔴Download the lateststablerelease from here:https://github.com/Significant-Gravitas/Auto-GPT/releases/latest.Themasterbranch may often be in abrokenstate.Auto-GPT is an experimental open-source application showcasing the capabilities of the GPT-4 language model. This program, driven by GPT-4, chains together LLM "thoughts", to autonomously achieve whatever goal you set. As one of the first examples of GPT-4 running fully autonomously, Auto-GPT pushes the boundaries of what is possible with AI.Demo April 16th 2023https://user-images.githubusercontent.com/70048414/232352935-55c6bf7c-3958-406e-8610-0913475a0b05.mp4Demo made byBlake Werlinger💖 Help Fund Auto-GPT's Development 💖If you can spare a coffee, you can help to cover the costs of developing Auto-GPT and help push the boundaries of fully autonomous AI!
Your support is greatly appreciated
Development of this free, open-source project is made possible by all thecontributorsandsponsors. If you'd like to sponsor this project and have your avatar or company logo appear belowclick here.🚀 Features🌐 Internet access for searches and information gathering💾 Long-Term and Short-Term memory management🧠 GPT-4 instances for text generation🔗 Access to popular websites and platforms🗃️ File storage and summarization with GPT-3.5📋 RequirementsEnvironment (pick one)VSCode + devcontainer: It has been configured in the .devcontainer folder and can be used directlyDockerPython 3.10 or later (instructions:for Windows)OpenAI API keyOptionalMemory backend (pick one)PineconeMilvusRedisWeaviateElevenLabs Key (If you want the AI to speak)⚠️ OpenAI API Keys Configuration ⚠️Obtain your OpenAI API key from:https://platform.openai.com/account/api-keys.To use OpenAI API key for Auto-GPT, youNEEDto have billing set up (AKA paid account).You can set up paid account athttps://platform.openai.com/account/billing/overview.PLEASE ENSURE YOU HAVE DONE THIS STEP BEFORE PROCEEDING, OTHERWISE NOTHING WILL WORK!💾 InstallationTo install Auto-GPT, follow these steps:Make sure you have all therequirementslisted above, if not, install/get themTo execute the following commands, open a CMD, Bash, or Powershell window by navigating to a folder on your computer and typingCMDin the folder path at the top, then press enter.Clone the repository: For this step, you need Git installed. Alternatively,
you can download thelatest stable release(Source code (zip), bottom of the page).gitclone-bstablehttps://github.com/Significant-Gravitas/Auto-GPT.gitNavigate to the directory where the repository was downloadedcdAuto-GPTInstall the required dependenciespipinstall-rrequirements.txtConfigure Auto-GPTLocate the file named.env.templatein the main/Auto-GPTfolder.Create a copy of this file, called.envby removing thetemplateextension. The easiest way is to do this in a command prompt/terminal windowcp .env.template .env.Open the.envfile in a text editor.Note: Files starting with a dot might be hidden by your Operating System.Find the line that saysOPENAI_API_KEY=.After the"=", enter your unique OpenAI API Key (without any quotes or spaces).Enter any other API keys or Tokens for services you would like to utilize.Save and close the.envfile.By completing these steps, you have properly configured the API Keys for your project.SeeOpenAI API Keys Configurationto obtain your OpenAI API key.Obtain your ElevenLabs API key from:https://elevenlabs.io. You can view your xi-api-key using the "Profile" tab on the website.If you want to use GPT on an Azure instance, setUSE_AZUREtoTrueand then follow these steps:Renameazure.yaml.templatetoazure.yamland provide the relevantazure_api_base,azure_api_versionand all the deployment IDs for the relevant models in theazure_model_mapsection:fast_llm_model_deployment_id- your gpt-3.5-turbo or gpt-4 deployment IDsmart_llm_model_deployment_id- your gpt-4 deployment IDembedding_model_deployment_id- your text-embedding-ada-002 v2 deployment IDPlease specify all of these values as double-quoted strings# Replace string in angled brackets (<>) to your own IDazure_model_map:fast_llm_model_deployment_id:"<my-fast-llm-deployment-id>"...Details can be found here:https://pypi.org/project/openai/in theMicrosoft Azure Endpointssection and here:https://learn.microsoft.com/en-us/azure/cognitive-services/openai/tutorials/embeddings?tabs=command-linefor the embedding model.🔧 UsageRunautogptPython module in your terminal.# On Linux of Mac:./run.sh# On Windows:.\run.batRunning with--helpafter.\run.batlists all the possible command line arguments you can pass.After each action, choose from options to authorize command(s),
exit the program, or provide feedback to the AI.Authorize a single command, enteryAuthorize a series ofNcontinuous commands, entery -NExit the program, enternLogsActivity and error logs are located in the./output/logsTo print out debug logs:python -m autogpt --debugDockerYou can also build this into a docker image and run it:dockerbuild-tautogpt.
dockerrun-it--env-file=./.env-v$PWD/auto_gpt_workspace:/app/auto_gpt_workspaceautogptOr if you havedocker-compose:docker-composerun--build--rmauto-gptYou can pass extra arguments, for instance, running with--gpt3onlyand--continuousmode:dockerrun-it--env-file=./.env-v$PWD/auto_gpt_workspace:/app/auto_gpt_workspaceautogpt--gpt3only--continuousdocker-composerun--build--rmauto-gpt--gpt3only--continuousCommand Line ArgumentsHere are some common arguments you can use when running Auto-GPT:Replace anything in angled brackets (<>) to a value you want to specifyView all available command line argumentspython-mautogpt--helpRun Auto-GPT with a different AI Settings filepython-mautogpt--ai-settings<filename>Specify a memory backendpython-mautogpt--use-memory<memory-backend>NOTE: There are shorthands for some of these flags, for example-mfor--use-memory. Usepython -m autogpt --helpfor more information🗣️ Speech ModeUse this to use TTS(Text-to-Speech)for Auto-GPTpython-mautogpt--speakList of IDs with names from eleven labs, you can use the name or ID:Rachel : 21m00Tcm4TlvDq8ikWAMDomi : AZnzlk1XvdvUeBnXmlldBella : EXAVITQu4vr4xnSDxMaLAntoni : ErXwobaYiN019PkySvjVElli : MF3mGyEYCl7XYWbV9V6OJosh : TxGEqnHWrfWFTfGW9XjXArnold : VR6AewLTigWG4xSOukaGAdam : pNInz6obpgDQGcFmaJgBSam : yoZ06aMxZJJ28mfd3POQ🔍 Google API Keys ConfigurationThis section is optional, use the official google api if you are having issues with error 429 when running a google search.
To use thegoogle_official_searchcommand, you need to set up your Google API keys in your environment variables.Go to theGoogle Cloud Console.If you don't already have an account, create one and log in.Create a new project by clicking on the "Select a Project" dropdown at the top of the page and clicking "New Project". Give it a name and click "Create".Go to theAPIs & Services Dashboardand click "Enable APIs and Services". Search for "Custom Search API" and click on it, then click "Enable".Go to theCredentialspage and click "Create Credentials". Choose "API Key".Copy the API key and set it as an environment variable namedGOOGLE_API_KEYon your machine. See setting up environment variables below.Enablethe Custom Search API on your project. (Might need to wait few minutes to propagate)Go to theCustom Search Enginepage and click "Add".Set up your search engine by following the prompts. You can choose to search the entire web or specific sites.Once you've created your search engine, click on "Control Panel" and then "Basics". Copy the "Search engine ID" and set it as an environment variable namedCUSTOM_SEARCH_ENGINE_IDon your machine. See setting up environment variables below.Remember that your free daily custom search quota allows only up to 100 searches. To increase this limit, you need to assign a billing account to the project to profit from up to 10K daily searches.Setting up environment variablesFor Windows Users:setxGOOGLE_API_KEY"YOUR_GOOGLE_API_KEY"setxCUSTOM_SEARCH_ENGINE_ID"YOUR_CUSTOM_SEARCH_ENGINE_ID"For macOS and Linux users:exportGOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"exportCUSTOM_SEARCH_ENGINE_ID="YOUR_CUSTOM_SEARCH_ENGINE_ID"PluginsSeehttps://github.com/Significant-Gravitas/Auto-GPT-Plugin-Templatefor the template of the plugins.⚠️💀 WARNING 💀⚠️: Review the code of any plugin you use, this allows for any Python to be executed and do malicious things. Like stealing your API keys.Drop the repo's zipfile in the plugins folder.If you add the plugins class name to theALLOWLISTED_PLUGINSin the.envyou will not be prompted otherwise you'll be warned before loading the plugin:ALLOWLISTED_PLUGINS=example-plugin1,example-plugin2,example-plugin3Setting Your Cache TypeBy default, Auto-GPT is going to use LocalCache instead of redis or Pinecone.To switch to either, change theMEMORY_BACKENDenv variable to the value that you want:local(default) uses a local JSON cache filepineconeuses the Pinecone.io account you configured in your ENV settingsrediswill use the redis cache that you configuredmilvuswill use the milvus cache that you configuredweaviatewill use the weaviate cache that you configuredMemory Backend SetupRedis SetupCAUTIONThis is not intended to be publicly accessible and lacks security measures. Therefore, avoid exposing Redis to the internet without a password or at allInstall docker (or Docker Desktop on Windows)Launch Redis containerdockerrun-d--nameredis-stack-server-p6379:6379redis/redis-stack-server:latestSeehttps://hub.docker.com/r/redis/redis-stack-serverfor setting a password and additional configuration.Set the following settings in.envReplacePASSWORDin angled brackets (<>)MEMORY_BACKEND=redisREDIS_HOST=localhostREDIS_PORT=6379REDIS_PASSWORD=<PASSWORD>You can optionally setWIPE_REDIS_ON_START=Falseto persist memory stored in Redis.You can specify the memory index for redis using the following:MEMORY_INDEX=<WHATEVER>🌲 Pinecone API Key SetupPinecone enables the storage of vast amounts of vector-based memory, allowing for only relevant memories to be loaded for the agent at any given time.Go topineconeand make an account if you don't already have one.Choose theStarterplan to avoid being charged.Find your API key and region under the default project in the left sidebar.In the.envfile set:PINECONE_API_KEYPINECONE_ENV(example:"us-east4-gcp")MEMORY_BACKEND=pineconeAlternatively, you can set them from the command line (advanced):For Windows Users:setxPINECONE_API_KEY"<YOUR_PINECONE_API_KEY>"setxPINECONE_ENV"<YOUR_PINECONE_REGION>"# e.g: "us-east4-gcp"setxMEMORY_BACKEND"pinecone"For macOS and Linux users:exportPINECONE_API_KEY="<YOUR_PINECONE_API_KEY>"exportPINECONE_ENV="<YOUR_PINECONE_REGION>"# e.g: "us-east4-gcp"exportMEMORY_BACKEND="pinecone"Milvus SetupMilvusis an open-source, highly scalable vector database to store huge amounts of vector-based memory and provide fast relevant search.setup milvus database, keep your pymilvus version and milvus version same to avoid compatible issues.setup by open sourceInstall Milvusor setup byZilliz CloudsetMILVUS_ADDRin.envto your milvus addresshost:ip.setMEMORY_BACKENDin.envtomilvusto enable milvus as backend.Optional:setMILVUS_COLLECTIONin.envto change milvus collection name as you want,autogptis the default name.Weaviate SetupWeaviateis an open-source vector database. It allows to store data objects and vector embeddings from ML-models and scales seamlessly to billion of data objects.An instance of Weaviate can be created locally (using Docker), on Kubernetes or using Weaviate Cloud Services.
Although still experimental,Embedded Weaviateis supported which allows the Auto-GPT process itself to start a Weaviate instance. To enable it, setUSE_WEAVIATE_EMBEDDEDtoTrueand make sure youpip install "weaviate-client>=3.15.4".Install the Weaviate clientInstall the Weaviate client before usage.$ pip install weaviate-clientSetting up environment variablesIn your.envfile set the following:MEMORY_BACKEND=weaviate
WEAVIATE_HOST="127.0.0.1" # the IP or domain of the running Weaviate instance
WEAVIATE_PORT="8080"
WEAVIATE_PROTOCOL="http"
WEAVIATE_USERNAME="your username"
WEAVIATE_PASSWORD="your password"
WEAVIATE_API_KEY="your weaviate API key if you have one"
WEAVIATE_EMBEDDED_PATH="/home/me/.local/share/weaviate" # this is optional and indicates where the data should be persisted when running an embedded instance
USE_WEAVIATE_EMBEDDED=False # set to True to run Embedded Weaviate
MEMORY_INDEX="Autogpt" # name of the index to create for the applicationView Memory UsageView memory usage by using the--debugflag :)🧠 Memory pre-seedingMemory pre-seeding allows you to ingest files into memory and pre-seed it before running Auto-GPT.# python data_ingestion.py -husage:data_ingestion.py[-h](--fileFILE|--dirDIR)[--init][--overlapOVERLAP][--max_lengthMAX_LENGTH]Ingestafileoradirectorywithmultiplefilesintomemory.Makesuretosetyour.envbeforerunningthisscript.
options:-h,--helpshowthishelpmessageandexit--fileFILEThefiletoingest.--dirDIRThedirectorycontainingthefilestoingest.--initInitthememoryandwipeitscontent(default:False)--overlapOVERLAPTheoverlapsizebetweenchunkswheningestingfiles(default:200)--max_lengthMAX_LENGTHThemax_lengthofeachchunkwheningestingfiles(default:4000)# python data_ingestion.py --dir DataFolder --init --overlap 100 --max_length 2000In the example above, the script initializes the memory, ingests all files within theAuto-Gpt/autogpt/auto_gpt_workspace/DataFolderdirectory into memory with an overlap between chunks of 100 and a maximum length of each chunk of 2000.Note that you can also use the--fileargument to ingest a single file into memory and that data_ingestion.py will only ingest files within the/auto_gpt_workspacedirectory.The DIR path is relative to the auto_gpt_workspace directory, sopython data_ingestion.py --dir . --initwill ingest everything inauto_gpt_workspacedirectory.You can adjust themax_lengthand overlap parameters to fine-tune the way the docuents are presented to the AI when it "recall" that memory:Adjusting the overlap value allows the AI to access more contextual information from each chunk when recalling information, but will result in more chunks being created and therefore increase memory backend usage and OpenAI API requests.Reducing themax_lengthvalue will create more chunks, which can save prompt tokens by allowing for more message history in the context, but will also increase the number of chunks.Increasing themax_lengthvalue will provide the AI with more contextual information from each chunk, reducing the number of chunks created and saving on OpenAI API requests. However, this may also use more prompt tokens and decrease the overall context available to the AI.Memory pre-seeding is a technique for improving AI accuracy by ingesting relevant data into its memory. Chunks of data are split and added to memory, allowing the AI to access them quickly and generate more accurate responses. It's useful for large datasets or when specific information needs to be accessed quickly. Examples include ingesting API or GitHub documentation before running Auto-GPT.⚠️ If you use Redis as your memory, make sure to run Auto-GPT with theWIPE_REDIS_ON_START=Falsein your.envfile.⚠️For other memory backend, we currently forcefully wipe the memory when starting Auto-GPT. To ingest data with those memory backend, you can call thedata_ingestion.pyscript anytime during an Auto-GPT run.Memories will be available to the AI immediately as they are ingested, even if ingested while Auto-GPT is running.💀 Continuous Mode ⚠️Run the AIwithoutuser authorization, 100% automated.
Continuous mode is NOT recommended.
It is potentially dangerous and may cause your AI to run forever or carry out actions you would not usually authorize.
Use at your own risk.Run theautogptpython module in your terminal:python-mautogpt--speak--continuousTo exit the program, press Ctrl + CGPT3.5 ONLY ModeIf you don't have access to the GPT4 api, this mode will allow you to use Auto-GPT!python-mautogpt--speak--gpt3onlyIt is recommended to use a virtual machine for tasks that require high security measures to prevent any potential harm to the main computer's system and data.🖼 Image GenerationBy default, Auto-GPT uses DALL-e for image generation. To use Stable Diffusion, aHugging Face API Tokenis required.Once you have a token, set these variables in your.env:IMAGE_PROVIDER=sdHUGGINGFACE_API_TOKEN="YOUR_HUGGINGFACE_API_TOKEN"SeleniumsudoXvfb:10-ac-screen01024x768x24&DISPLAY=:10<YOUR_CLIENT>⚠️ LimitationsThis experiment aims to showcase the potential of GPT-4 but comes with some limitations:Not a polished application or product, just an experimentMay not perform well in complex, real-world business scenarios. In fact, if it actually does, please share your results!Quite expensive to run, so set and monitor your API key limits with OpenAI!🛡 DisclaimerDisclaimer
This project, Auto-GPT, is an experimental application and is provided "as-is" without any warranty, express or implied. By using this software, you agree to assume all risks associated with its use, including but not limited to data loss, system failure, or any other issues that may arise.The developers and contributors of this project do not accept any responsibility or liability for any losses, damages, or other consequences that may occur as a result of using this software. You are solely responsible for any decisions and actions taken based on the information provided by Auto-GPT.Please note that the use of the GPT-4 language model can be expensive due to its token usage.By utilizing this project, you acknowledge that you are responsible for monitoring and managing your own token usage and the associated costs. It is highly recommended to check your OpenAI API usage regularly and set up any necessary limits or alerts to prevent unexpected charges.As an autonomous experiment, Auto-GPT may generate content or take actions that are not in line with real-world business practices or legal requirements. It is your responsibility to ensure that any actions or decisions made based on the output of this software comply with all applicable laws, regulations, and ethical standards. The developers and contributors of this project shall not be held responsible for any consequences arising from the use of this software.By using Auto-GPT, you agree to indemnify, defend, and hold harmless the developers, contributors, and any affiliated parties from and against any and all claims, damages, losses, liabilities, costs, and expenses (including reasonable attorneys' fees) arising from your use of this software or your violation of these terms.🐦 Connect with Us on TwitterStay up-to-date with the latest news, updates, and insights about Auto-GPT by following our Twitter accounts. Engage with the developer and the AI's own account for interesting discussions, project updates, and more.Developer: Follow@siggravitasfor insights into the development process, project updates, and related topics from the creator of Entrepreneur-GPT.Entrepreneur-GPT: Join the conversation with the AI itself by following@En_GPT. Share your experiences, discuss the AI's outputs, and engage with the growing community of users.We look forward to connecting with you and hearing your thoughts, ideas, and experiences with Auto-GPT. Join us on Twitter and let's explore the future of AI together!Run testsTo run all tests, run the following command:pytestTo run just without integration tests:pytest --without-integrationTo run just without slow integration tests:pytest --without-slow-integrationTo run tests and see coverage, run the following command:pytest--cov=autogpt--without-integration--without-slow-integrationRun linterThis project usesflake8for linting. We currently use the following rules:E303,W293,W291,W292,E305,E231,E302. See theflake8 rulesfor more information.To run the linter, run the following command:flake8autogpt/tests/# Or, if you want to run flake8 with the same configuration as the CI:flake8autogpt/tests/--selectE303,W293,W291,W292,E305,E231,E302 |
agptools | agp ToolsMinimal Tools not found in python libraryFree software: MIT licenseDocumentation:https://agptools.readthedocs.io.FeaturesTODOBefore Codingcreate a virtual env::python3 -m venv venv
source venv/bin/activate
make install-testing-requisitesCreditsThis package was created withCookiecutterand thecib_pypackageproject template.History0.1.0 (2024-01-15)First release on PyPI. |
agpt-plugins | Auto-GPT-PluginsPlugins for Auto-GPTClone this repo into the plugins direcory ofAuto-GPTFor interactionless use, setALLOWLISTED_PLUGINS=example-plugin1,example-plugin2,example-plugin3in your.envPluginDescriptionTwitterIt does twitter things |
agpt-plugin-template | (Coming Soon) Auto-GPT-Plugin-TemplateA starting point for developing your own plug-in for Auto-GPT |
agpy | A collection of astronomy-related tools. Please see thepackage documentation.CHANGESRelease 0.1.3Version, manifest fixes.Release 0.1.2Bugfix. Imports should now workRelease 0.1.1First pypi release. Made mpfit an agpy subpackage |
agpypeline | Package containing entrypoint.py from entrypoint code and environment.py for drone-specific environment code. This allows for transformers to havecommon entrypoint and environment code in an installable package |
agpypeline-templates | templatestemplate testing file which can be used for different image file types |
agpypelinetest | Failed to fetch description. HTTP Status Code: 404 |
agpypelinetest1 | Package containing entrypoint.py from entrypoint code and transformer_class.py for drone-specific environment code. This allows for transformers to havecommon entrypoint and environment code in an installable package |
agpytesting | Package containing entrypoint.py from entrypoint code and environment.py for drone-specific environment code. This allows for transformers to havecommon entrypoint and environment code in an installable package |
agrafena | agrafenaPython TN3270 automation library.SeeGitHubfor more information. |
agraffe | Agraffe, build API with ASGI in Serverless services (e.g AWS lambda, Google Cloud Functions and Azure Functions).Support ServicesGoogle Cloud FunctionsPython 3.7, 3.8, 3.9, 3.10, 3.11(preview)AWS lambda (with API Gateway HTTP API or REST API, or with Function URL)Python 3.7, 3.8, 3.9Azure FunctionsPython 3.7, 3.8, 3.9, 3.10(preview)RequirementsPython 3.7+Installation$pipinstallagraffeExampleCreate itCreate a filemain.pywith:importcontextlibfromagraffeimportAgraffefromfastapiimportFastAPI,[email protected](app):yield{'message':'hello'}app=FastAPI(lifespan=lifespan)@app.get("/")defread_root():return{"Hello":"World"}@app.get("/items/{item_id}")defread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}@app.get("/lifespan")deflifespan_(request:Request):return{"count":request.state.message}entry_point=Agraffe.entry_point(app)# or, for on GCPfromagraffe.services.google_cloud_functionsimportHttpCycledefentry_point(request):returnAgraffe(app,HttpCycle)(request=request)Deploy itDeploy the api with:$gcloudfunctionsdeploy{FUNCTIONNAME}--entry-pointentry_point--runtimepython310--trigger-http--allow-unauthenticatedSee/examplefor other services.LicenseThis project is licensed under the terms of the MIT license. |
agrajag | agrajagShort blurb about what your product does.One to two paragraph statement about your product and what it does.ContentsDemoProject rationaleQuick startPrerequisitesInstallationBasic UsageUsageDevelopment setupConfigurationDocumentationRead the DocsAPIWikiFAQsWhat's new in version x.xPlanned future enhancementsPackage statisticsLicenseMeta information📺 DemoPut a demo animated gif here.💡 Project rationaleWhy I built this project👓 TLDRA very succinct paragraph summary regarding the package purpose and operation.🚀 QuickstartExplain succinctly how to use the repository📋 PrerequisitesA bulleted list of requirements💾 InstallationOS X & Linux:pip3installagrajagWindows:pipinstallagrajag📝 Basic UsageA simple example demonstrating that the package is working📝 UsageA few motivating and useful examples of how your product can be used. Spice this up with code blocks and potentially more screenshots.For more examples and usage, please refer to theWiki.🔧 Development setupDescribe how to install all development dependencies and how to run an automated test-suite of some kind. Potentially do this for multiple platforms.pipinstall--editableagrajag⚙️ ConfigurationPlace configuration information here🔒 Security ConsiderationsWrite any security concerns that you may have here.
e.g. exposure of API keys, passwords, old modules etc.📚 DocumentationRead the DocsExample UsageCreditsChangelogAPI ReferenceWiki🧬 Design ConsiderationsA few paragraphs on the design considerations if required.🐳 Using DockerBuilding the Image from DockerfileStart your docker runtime then:Build the image usingdocker buildcommand. e.g.$dockerbuild-tsraking/agrajag:0.1.0-tsraking/agrajag:latest.Once built, run the image using thedocker runcommand. This will create the container. e.g.$dockerrun-itsraking/agrajag:0.1.0/bin/bashOptional: The image can now be pushed to the repository using thedocker pushcommand. e.g.$dockerpushsraking/agrajag:0.1.0Using the ready built image on dockerhubPull the latest image from the repository using thedocker pullcommand. e.g.~$dockerpullsraking/agrajagNow run the image using thedocker runcommand. This will create the container. e.g.~$dockerrun-itsraking/agrajag/bin/bashUse the command line as normal in the container.root@4d315992ca28:/app#agrajag-h⚠️ LimitationsDescribe any limitation the application may have (if any).⁉️ Some QuirksThe reason I wrote this application in the first place.❓ FAQsGive examples of frequently asked questions📰 What's new in version x.xbulleted list of new features📆 Planned future enhancementsFeature 1Feature 2📊 Package statisticslibraries.ioPyPI StatsPepy📜 LicenseDistributed under the MIT license. Seefor more information.<ℹ️> MetaAuthor: Stephen R A King ([email protected])Created with Cookiecutter template:version 1.3.4Digital object identifier: |
agralogics | Weather ModelsThis is a simple example package. You can useGithub-flavored Markdownto write your content. |
agram | Telegram MTProto API Framework for PythonHomepage•Documentation•Releases•NewsagramElegant, modern and asynchronous Telegram MTProto API framework in Python for users and botsfromagramimportClient,filtersapp=Client("my_account")@app.on_message(filters.private)asyncdefhello(client,message):awaitmessage.reply("Hello from agram!")app.run()agramis a modern, elegant and asynchronousMTProto APIframework. It enables you to easily interact with the main Telegram API through a user account (custom client) or a bot
identity (bot API alternative) using Python.Key FeaturesReady: Install agram with pip and start building your applications right away.Easy: Makes the Telegram API simple and intuitive, while still allowing advanced usages.Elegant: Low-level details are abstracted and re-presented in a more convenient way.Fast: Boosted up byTgCrypto, a high-performance cryptography library written in C.Type-hinted: Types and methods are all type-hinted, enabling excellent editor support.Async: Fully asynchronous (also usable synchronously if wanted, for convenience).Powerful: Full access to Telegram's API to execute any official client action and more.Installingpip3installagramResourcesCheck out the docs athttps://selamarket.shopto learn more about agram, get started right
away and discover more in-depth material for building your client applications.Join the official channel athttps://t.me/XTIORYand stay tuned for news, updates and announcements. |
agraph | No description available on PyPI. |
agraph-python | The AllegroGraph Python API offers convenient and efficient access to
an AllegroGraph server from a Python-based application. This API
provides methods for creating, querying and maintaining RDF data, and
for managing the stored triples. The AllegroGraph Python API
deliberately emulates the Eclipse RDF4J (formerly Aduna Sesame) API to
make it easier to migrate from RDF4J to AllegroGraph. The AllegroGraph
Python API has also been extended in ways that make it easier and more
intuitive than the RDF4J API.RequirementsPython versions>=3.8,<3.12are supported. The installation method
described here uses the pip package manager. On some systems this
might require installing an additional package (e.g.python-pipon
RHEL/CentOS systems). All third-party libraries used by the Python
client will be downloaded automatically during installation.InstallationImportantIt is highly recommended to perform the install in avirtualenvenvironment.The client can be installed fromPyPIusing thepippackage
manager:pip install agraph-pythonAlternatively, a distribution archive can be obtained fromftp://ftp.franz.com/pub/agraph/python-client/and installed usingpip:pip install agraph-python-<VERSION>.tar.gzOffline installationIf it is not possible to accessPyPIfrom the target machine, the
following steps should be taken:In a compatible environment with unrestricted network
access run:pip wheel agraph-pythonThis will generate a number of.whlfiles in the current
directory. These files must be transferred to the target machine.On the target machine use this command to install:pip install --no-index --find-links=<DIR> agraph-pythonwhere<DIR>is the directory containing the.whlfiles
generated in the previous step.TestingTo validate the installation make sure that you have access to an
AllegroGraph server and run the following Python script:from franz.openrdf.connect import ag_connect
with ag_connect('repo', host='HOST', port='PORT',
user='USER', password='PASS') as conn:
print (conn.size())Substitute appropriate values for the HOST/PORT/USER/PASS
placeholders. If the script runs successfully a new repository namedrepowill be created.Proxy setupIt is possible to configure the AllegroGraph Python client to use a
proxy for all its connection to the server. This can be achieved by
setting theAGRAPH_PROXYenvironment variable, as in the following
example:# Create a SOCKS proxy for tunneling to an internal network
ssh -fN -D 1080 [email protected]
# Configure agraph-python to use this proxy
export AGRAPH_PROXY=socks://localhost:1080The format of theAGRAPH_PROXYvalue isTYPE://HOST:PORT,
whereTYPEcan be eitherhttp,socks4,socks5orsocks(a synonym forsocks5). Note that if a SOCKS proxy is
used, DNS lookups will be performed by the proxy server.Unit testsThe Python client includes a suite of unit tests that can be run after
installation. The tests are executed using thepytestframework
and also use a few utilities fromnose, so these two packages have
to be installed. We also need thepytest-mockplugin:pip install -e ".[test]"The tests require a running AllegroGraph server instance. The
configuration of this server is passed to the tests through
environment variables:# Host and port where the server can be reached. These values are the
# default, it is only necessary to define the variables below if your
# setup is different
export AGRAPH_HOST=localhost
export AGRAPH_PORT=10035
# Tests will create repositories in this catalog.
# It must exist on the server. Use "/" for the root catalog.
export AGRAPH_CATALOG=tests
# Login credentials for the AG server.
# The user must have superuser privileges.
export AGRAPH_USER=test
# Use a prompt to read the password
read -s -r -p "Password for user ${AGRAPH_USER}: " AGRAPH_PASSWORD
export AGRAPH_PASSWORDTo run the tests, type:pytest --pyargs franz.openrdf.tests.tests --pyargs franz.openrdf.tests.newtests |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.