Saravanan666/pypi-org huggingface dataset:
Package: fao56-model
Fao56 ModelThis is an implementation of theFAO56 model.
Only the method where the effect of both crop transpiration and soil evaporation are integrated into a single crop coefficient is implemented now.TO DOensure that the limits umean and avg_RHmin is respected for the correlationimplement irrigation method to calculate the ideal water deliveryimplement irrigation method to calculate maximum yield given max potential water delivery per dayadd the crop coefficient correction for the initial stagegeneralize the outputadd the dual crop coefficient methodadd more crops to the databasevalidate the model using the FAO56 dataadd testsDevelopmentTo install all the dependenciespoetry install --with devInstall the pre-commit hookspre-commit installTo testpoetry run pytestBump the version to publishpoetry version patch
git add fao56_model
git commit -am 'Bump version'
git push
Package: faodata
A simple python interface to download data from the Food and Agriculture Organisation (FAO).What is faodata?faodata is a simple python interface to find and request data from
the Food and Agriculture organization of the United Nations
(FAO).The package uses theFAO API.Country boundaries that are used to plot data are fromNatural Earth
(1:110m
resolution)Installationpip install faodataor download thesource
codeandpython setup.py installBasic useTo download data, the id of the database, dataset and fields are
required:To get the list of FAO databases:fromfaodataimportfaodownloaddatabases=faodownload.get_databases()To get the list of FAO datasets in a given database (e.g. faostat):database_id='faostat'datasets=faodownload.get_datasets(database_id)To get the list of FAO fields in a given dataset (e.g. live-prod):database_id='faostat'dataset_id='live-prod'fields=faodownload.get_fields(database_id,dataset_id)When all the previous elements are known, the download procedure isdatabase_id='faostat'dataset_id='live-prod'field_id='m5111'# Define the year (if None, all years are retrieved)year=2010# Define country (if None, all countries are retrieved)# The country id is the ISO3 code# see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3country_id=None# Get datadata=faodownload.get_data(database_id,dataset_id,field_id,country=country_id,year=year)When data is downloaded, it can be displayed on a world mapimportnumpyasnpimportmatplotlib.pyplotaspltfrommpl_toolkitsimportbasemapfromfaodataimportfaodownload,faomap# Download datadatabase_id='faostat'dataset_id='live-prod'field_id='m5111'year=2013data=faodownload.get_data(database_id,dataset_id,field_id,year=year)# Select dataitem='Cattle'idx=data['Item']==itemdata=data.loc[idx,['country','value']]# Instantiate matplotlib and basemap objectsplt.close('all')fig,ax=plt.subplots()map=basemap.Basemap(projection='robin',\lon_0=10,lat_0=50,ax=ax)map.drawcoastlines(color='grey')map.drawcountries(color='grey')# Categorize data according to percentilescat=[np.percentile(data['value'],pp)\forppinrange(10,100,10)]# Draw plotfaomap.plot(map,data,cat,ndigits=0)map.ax.legend(loc=3)ax.set_title('%spopulation,%d'%(item,year),fontsize=15)# Add a footer to the figure to# indicate data sourcefaomap.mapfooter(fig,database_id,dataset_id,field_id)More examples in theexample folderdirectory.
Package: faons
Welcome to Fast API on Steroids(FAONS)!Hi! we have created faons to help those who are struggling to setup a base project for fast api with swagger ui. My team used to either copy paste or create manually the files and folders necessary for fast api. But with this package anyone can easily start a fast api project.InstallingUse the commandpip install faonsto install the latest version of faons in your environment.Creating your first projectOnce the package has been installed you can create your first project using the commandfaons intializeproject <project_name>.File structureAll your files and folders are created as per the below representation├── src
│   ├── config
│   │   ├── config.py
|   |   └── constants.py
│   ├── core
│   ├── logger
├── conf
│   ├──__init__.py
│   ├── env.conf
├── utils.py
├── settings.py
├── main.py 
└── README.mdThemain.pyfile will be responsible for running your application. Thesettings.pyfile will be used for including the settings (eg: database connections) for the application. Theutils.pycontains the necessary utilities to run the application.Creating you first app for your projectFAONS inherit the idea of creating apps from Django. We will be creating different apps to separate different modules in our application. We can create apps by using the commandfaons startapp <app_name>. Once done the app folder will be created inside thesrc/corefolder.Updating your schema to the DBOne useful feature that we missed while coming from django to fastapi was that it lacked the feature to migrate the schema to its db easily. With faons v 0.0.4 we included a function do exactly the same thing. You can use the commandfaons updateschemawhich will create, alter or drop tables based on the changes that you make to theschema.pyin the apps. From faons v 0.0.5 we started to create an additional table faons_schema which will be used to track the table names. This table was included to avoid issues like deleting tables exported from models file.Migrating models to DBJust like exporting schema to DB the ability to export models directly to you DB has been added to faons from v 0.0.6. You can use the commandfaons updatemodelswhich will create, alter or drop tables based on the changes that you make to themodels.pyin the apps. This command also creates a table called faons_models which will be used to track the table names created from the models.
Package: fapistrano
# FapistranoA remote server automation and deployment tool.Document: [http://pythonhosted.org/fapistrano/](http://pythonhosted.org/fapistrano/)## Install` bash pip install fapistrano `To upgrade` bash pip install-Ufapistrano `## How to Use` $ fap release--stageproduction--roleweb $ fap rollback--stageproduction--roleweb $ fap restart--stageproduction--roleweb `History0.9.2 (2017-03-20)fix contaminated outdated releases.0.9.1 (2016-9-18)fix stale releases left on servers.0.9.0 (2016-4-21)support different login user and sudo user.0.8.3 (2016-4-18)fix missing output from curl.fix .env format.support formatted env for list/dict.0.8.2 (2016-4-9)add–dry-runoption.0.8.1 (2016-4-1)hide curl password.0.8.0 (2016-3-30)add commandonce.add commandshell(only support python now).find plugins for each command if possible, fallback to default plugin.add.envfile at remote.0.7.3 (2016-3-29)bugfix for cross env pollution.0.7.2 (2016-3-29)cli support group deploy by role or stage.add option–curl-extract-tgz.add option–git-archive-tree.0.7.1 (2016-3-25)fix fis option.add option–shared_writable.alert on missing localshared files.add option–curl-postinstall-output.add option–curl-output.0.7.0 (2016-3-21)release to pypi.0.6.0 (2016-3-15)move git, supervisor, slack as plugins.put git bare repo on path.add fis plugin.addfapcli.use signal to refactor release/rollback flow.add curl plugin.add supervisor plugin.0.5.1 (2015-2-1)support supervisor groupslack notification.0.1.0 (2015-9-23)First release.
Package: fa-profiler
Formulated Autoamation RPA Resources/r/OpenSourceRPAOpenSource RPA LinkedIn
GroupFormulatedAutomation's YouTube
ScreencastsFormulated Automation PodcastFormulatedAutomation-ProfilerIntroductionThe purpose of this project is to record a snapshot of the runtime
environment for an automation workspace. This includes recording
installed applications and their versions on the machine. This is
especially useful when automations stop working and allows for rapid
debugging of machine prior and current states.⚠️ This project is currently a work in process and should not be used in
production environments. ⚠️InstallationCreate a virtual environmentpip install fa-profilerUsageProfiler*** Settings ***
Library                 FormulatedAutomation.Profiler
Suite Teardown          Teardown

*** Keywords ***
Teardown
    Write ProfileIf you look in the 'output' directory (which is the current directory, or
whatever you speficy at runtime), you'll find an fa_report.yml file.
In this file is a profile of the system you ran on, which includes things likePython version and installed packagesEnvironment variablesRobot Framework variables (Secrets omitted)Installed programs(on Windows)It's organized in a way that makes 'diffing' it with a previous report trivial
and therefore makes it easy to see what's changed between runs.Sample Report from Windows CISample Report from Linux CIOmitting secrets from the profileThere's a good chance you're setting a varaible to something you don't want
listed in the logs. In order to prevent secrets from leaking, Profiler will
'redact' any variables with 'secret' in their name. This will later be
configurable.DebuggingThe Formulated Automation Profiler also includes some basic debugging tools.*** Settings ***
Library                 FormulatedAutomation.Profiler
Suite Teardown          Teardown

*** Keywords ***
Teardown
    Pause On Failure # Launch a Dialog to pause execution whenever a task fails
    Write Profile

*** Keywords ***
Some Task
    Set Breakpoint # Pause execution and drop to Python's 'pdb' debugger
    Do Some Other Task
    Pause for Debug # Pause with a Dialog regardless of failurePause on Failure and Pause for Debug only occur if the environment variable
'ROBOT_DEBUG' is set to TRUE. This prevents pausing in production if the
keywords are accidentally set.Command Line Example:Powershell:$Env:ROBOT_DEBUG = "TRUE"; robot -d output -P src testsBash:ROBOT_DEBUG=TRUE && robot -d output -P src testsTestingThis library expects teh ROBOT_DEBUG environment variable to be set.
You can do this however suits your platform:Powershell:$Env:ROBOT_DEBUG = "TRUE"; robot -d output -P src testsBash:ROBOT_DEBUG=TRUE && robot -d output -P src testsExecute the tests in this project:robot -d output -P src tests
Package: fa-py
# FactorApy
A Python package to for performing Factor analysis on any given data.## UsageThere are 2 base classes in this library. <br>
1. FA_Tests()
2. FA()To use the library` import fa_py ... fa = fa_py.FA_Tests() ## Class initializer fa.kmo(X) ## Pass the dataframe to calculate the KMO test scores ... `
Package: faqap
Fast Approximate Quadratic Assignment Problem SolverThis is a Python implementation of an algorithm for approximately solving quadratic
assignment problems described inJoshua T. Vogelstein and John M. Conroy and Vince Lyzinski and Louis J. Podrazik and
Steven G. Kratzer and Eric T. Harley and Donniell E. Fishkind and
R. Jacob Vogelstein and Carey E. Priebe
(2012) Fast Approximate Quadratic Programming for Large (Brain) Graph Matching.arXiv:1112.5507.It solvesmin𝑃∈𝒫<𝐹, 𝑃𝐷𝑃𝖳>where 𝐷, 𝐹 ∈ ℝ𝑛×𝑛, 𝒫 is the set of 𝑛×𝑛 permutation matrices
and <., .> denotes the Frobenius inner product.The implementation employs theFrank–Wolfe algorithm.Exampleimportnumpyasnpfromfaqapimportminimize# Make runs deterministic, descent origins are chosen randomly by default.np.random.seed(123456789)D=np.array([[0,0,0,-4],[0,0,-3,0],[0,-2,0,0],[-1,0,0,0]],dtype=np.float64)F=np.array([[0,0,0,+1],[0,0,+2,0],[0,+3,0,0],[+4,0,0,0]],dtype=np.float64)solution_permutation=minimize(D=D,F=F,descents_count=1).x# Expected is the permutation reversing elements.print("solution permutation =",solution_permutation)Outputsolution permutation = [3 2 1 0]GPU SupportGPU support is enabled through Torch. It is an optional dependency.
In order to use the GPU you must pass Torch tensors that are on the CUDA device.
If you pass CPU tensors the GPU will not be used.Note that linear sum assignment, which is a part of the algorithm, is done on
the CPU though SciPy.
On a system with GPU GeForce RTX 2080 SUPER and
CPU AMD Ryzen Threadripper 2920X (single thread at 3.5 - 4.3 GHz)
for a float32, 128 sized problem linear sum assignment takes ~60% of the
execution time.
It may be possible to move that part on the GPU as well, but currently
there are no good off-the-shelf GPU implementations for that.
It is also unclear if there will be any significant speedup.Installationpip install faqapDependenciesPython (>=3.5)NumPy (>=1.10)SciPy (>=1.4)Torch (optional)
Package: faq-migrations
# FAQ Alembic Git Migration> This module created as wrapper for Alembic and the main idea is> attaching real git branch, monitoring heads and auto-recommendations> for merging when developer creates new migration.# How to install```bashpip install faq-migrations```# Add CLI to your project> As standalone manager```pythonfrom faq_migrations.cli import migrationsif __name__ == '__main__':migrations()```> As sub-group of click```pythonimport clickfrom faq_migrations.cli import migrationscli = click.Group()cli.add_command(migrations)if __name__ == '__main__':cli()```> and run cli```bashpython your_manager.py migrations --help```# List of commands:```Usage: manager.py migrations [OPTIONS] COMMAND [ARGS]...Creating of new migrations and upgrading databaseOptions:--help  Show this message and exit.Commands:compare_history     Compare local and remote historycreate              Create new migration for current branchcurrent             Show current migration revisionheads               Show current headshistory             Show last migration, limit=20, upper=Trueinit                Initialize new alembic directorylast_revision       Show previous migrationmerge               Merge branches or headsmigrate             Upgrade to headupgrade_migrations  Show not yet applied migrations```# Config settings```pythonfrom faq_migrations.settings import config# Path to your directory with alembic.iniconfig.config_file_path = 'faq_migrations/migrations/'# Path to templates directory with alembic.ini and mako filesconfig.template_path = 'faq_migrations/templates/'# Default template nameconfig.template_name = 'git-generic'# Path to your directory with migrationsconfig.alembic_dir = 'migrations/'# You can setup database url in this param or in alembic.ini.# This parameter has higher priorityconfig.database_url = 'driver://username:pass@host:port/db_name'```> Before initializing new directory with migrations you must setup config> params.# Building and Publication### Build```bashpython setup.py sdisttwine upload dist/*```### Publication```bashpip install twinetwine upload dist/*```
Package: faqtory
FAQtoryFAQtory is a tool to auto-generate aFAQ.md(Frequently Asked Questions) document for your project.Additionally, a "suggest" feature uses fuzzy matching to reply to GitHub issues with suggestions from your FAQ.Getting startedFaqtory is best installed viapipxto avoid any dependency conflicts:pipxinstallfaqtoryRun the following from the directory you wish to store the FAQ document.faqtoryinitThis will create the following files and directories:faq.ymlA configuration file which you can edit../.faq/A directory which will contain templates../questions/A directory containing question documents.Adding questionsTo add questions create a file with the extension.question.mdin the questions directory (./questions/if you are using the defaults).Question documents are Markdown with front-matter. Here's an example:---
title: "What does FAQ stand for?"
alt_titles:
  - "What is the meaning of FAQ?"
  - "What does FAQ mean?"
---

FAQ stands for *Frequently Asked Questions*The filename is unimportant, but atitleis mandatory. You can also optionally add alternative titles underalt_titleswhich will be used with thefaqtory suggestfeature (but not displayed).BuildingRun the following command to build the FAQ:faqtorybuildWith the default settings this will generate anFAQ.mdfile.SuggestThe "suggest" subcommand can compile a list of FAQ entries that match a supplied issue title. Here's an example:faqtorysuggest"who is the author of FAQtory?"This will generate a list of matching entries from the FAQ, and write Markdown to stdout. You can modify the output with the "suggest.md" template, which you will find in your ".faq/" directory (if you haven't configured it elsewhere),This feature is designed to be used with a GitHub action to post an automated response. To enable this feature, copynew_issue.ymlto a similarly named directory in your repository.DisclaimerThis was a hastily put together tool by a maintainer that was tired of responding to the same old issues. I can't devote much time to this project, but I will happily accept PRs!
Package: farabio
farabioWhat's NewIntroductionFeaturesBiodatasetsModelsGetting Started (Installation)TutorialsLinksCreditsLicensesAcknowledgementsWhat's NewAugust 18, 2021Release offarabio==0.0.2April 21, 2021This work is presented at PyTorch Ecosystem day. Poster ishere.April 2, 2021Release offarabio==0.0.1March 3, 2021This work is selected for PyTorch Ecosystem Day.Introductionfarabiois a minimal PyTorch toolkit for out-of-the-box deep learning support in biomedical imaging. For further information, seeWikisandDocs.FeaturesBiomedical datasetsCommon DL modelsFlexible trainers (*in progress)BiodatasetsChest X-Ray Images (Pneumonia):https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia2018 Data Science Bowl:https://www.kaggle.com/c/data-science-bowl-2018/overviewHistopathologic Cancer Detection:https://www.kaggle.com/c/histopathologic-cancer-detection/overviewRANZCR CLiP - Catheter and Line Position Challenge:https://www.kaggle.com/c/ranzcr-clip-catheter-line-classification/overviewAPTOS 2019 Blindness Detection:https://www.kaggle.com/c/aptos2019-blindness-detection/overviewModelsClassification:AlexNet -https://papers.nips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdfGoogLeNet -https://arxiv.org/pdf/1409.4842.pdfMobileNetV2 -https://arxiv.org/pdf/1801.04381.pdfMobileNetV3 -https://arxiv.org/pdf/1905.02244.pdfResNet -https://arxiv.org/pdf/1512.03385.pdfShuffleNetV2 -https://arxiv.org/pdf/1807.11164.pdfSqueezeNet -https://arxiv.org/pdf/1602.07360.pdfVGG -https://arxiv.org/pdf/1409.1556.pdfSegmentation:DeepLabV3 -https://arxiv.org/pdf/1706.05587U-Net -https://arxiv.org/pdf/1505.04597LinkNet -https://arxiv.org/pdf/1707.03718PSPNet -https://arxiv.org/pdf/1612.01105FPN -http://presentations.cocodataset.org/COCO17-Stuff-FAIR.pdfGetting started (Installation)1. Activatecondaenvironment:condacreate-nmyenvpython=3.8
condaactivatemyenv2. InstallPyTorch:pipinstalltorch==1.9.0+cu111torchvision==0.10.0+cu111torchaudio==0.9.0-fhttps://download.pytorch.org/whl/torch_stable.html3. Installfarabio:A. With pip:pipinstallfarabioB. Setup from source:gitclonehttps://github.com/tuttelikz/farabio.git&&cdfarabio
pipinstall.TutorialsTutorial 1:Training a classifier forChestXrayDataset-NotebookTutorial 2:Training a segmentation model forDSB18Dataset-NotebookLinksAPI documentations:https://farabio.readthedocs.ioCode:https://github.com/tuttelikz/farabioIssue tracker:https://github.com/tuttelikz/farabio/issuesPyPI package:https://pypi.org/project/farabio/Wiki:https://github.com/tuttelikz/farabio/wikiCreditsIf you like this repository, please click on Star.LicensesThis work is licensedApache 2.0.AcknowledgementsThis work is based upon efforts of open-source PyTorch Community. I have tried to acknowledge related works (github links, arxiv papers) inside the source material, eg. README, documentation, and code docstrings. Please contact if I missed anything.
Package: faraday-agent-parameters-types
Faraday Agent Parameters TypesThefaraday agentsrun code remotely to secure your domains. This info is triggered and published to afaraday serverinstance, which had set the parameters of the code. This repository sets the models to
be used by both sides.FeaturesSet the models of parameters types for the agents:How to pass them by identifier stringsHow to encode/decode them to pass data between theFaraday server, and theagentsCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.1.0.1 [Aug 9th, 2021]:New manifest for InsightVM agentRemove HOST and API from parameters1.0.0 [Jun 29th, 2021]:First release of module0.1.0 [May 14th, 2021]:Release of first stable version, to use in multiples pipelines0.1.0a1 [Apr 22nd, 2021]:Encode/Decode the types, plus identifier logicFirst release of the package, in alpha status
Package: faradaydreams
Faraday-DreamsNew developments that allow correction for channel averaging when reconstructing broad band polarimetric signals.This code is built usingOptimus Primalto apply convex optimization algorithms in deniosing.RequirementsPython 3.8Optimus PrimalPyNUFFTwhen using the NUFFT algorithm (Optional)InstallYou can install from the master branchpip install git+https://github.com/Luke-Pratley/Faraday-Dreams.git@master#egg=faradaydreamsor from a frozen version atpypipip install faradaydreamsRelated PublicationsRemoving non-physical structure in fitted Faraday rotated signals: non-parametric QU-fitting, PASA (Accepted), L. Pratley and M. Johnston-Hollitt, and B. M. Gaensler, 2021Wide-band Rotation Measure Synthesis, ApJ, L. Pratley, M. Johnston-Hollitt, 2020Basic example for 1d spectrumWe can import a simple solver using the following commandimport faradaydreams.recover_faraday_spectra as recover_faraday_spectraWe can define a dictionary with variables such as the tolerance for convergencetol, the maximum number of iterationsiter, and if we wish to enforce that $\lambda^2 \leq 0$ has zero fluxproject_positive_lambda2. We expect the Faraday depth signal to be complex valued, so the real and positivity constraints areFalse.options = {
    'tol': 1e-5,
    'iter': 50000,
    'update_iter': 1000,
    'record_iters': False,
    'real': False,
    'positivity': False,
    'project_positive_lambda2': False
}Below we pass data to the solver which returns a dictionary with processed result. We pass in the Stokes Q and U spectra and their associated errors in Jy.
We provide the channel frequencies (in Hz) and withchannel_width=Nonewe do not correct for channel averaging, if we pass the array of channel widths in Hz it will try to do a correction.The size of a Faraday width pixel is chosen to bedphi=15rad/m^2 and we choose the spectrum to spanNphi=320pixels across centred at 0 rad/m^2.
We choose not to scale the uncertainty on the measurements that we wish to fit the solution withsigma_factor=1.beta=1e-2is the step size for the minimization, and1e-0to1e-3normally works well.results = recover_faraday_spectra.recover_1d_faraday_spectrum(
    Q=data['Q'],
    U=data['U'],
    error_Q=data['e_Q'],
    error_U=data['e_U'],
    freq=freq,
    dphi=15,
    Nphi=320,
    sigma_factor=1,
    beta=1e-2,
    options=options,
    channel_widths=None)The returned dictionary has the formreturn {
        "solution": solution,
        "phi": phi,
        "y_solution": y_model,
        "solution_lambda2": model_lambda2,
        "measurements": y,
        "measurements_residuals": y - m_op.dir_op(solution) / weights,
        "measurements_lambda2": lambda2,
        "measurements_weights": weights,
        "measurements_sigma": sigma
    }where we can plot the solutionresults['solution']againstresults['phi'].results['y_solution']is the same signal in lambda^2 coordinatesresults['solution_lambda2']. The original measurementsresults['measurements']and the residuals of the solutionresults['measurements_residuals']are also returned.Look in the examples directory for a fully working example in the form of a python notebook.