Saravanan666/pypi-org huggingface dataset:
Package: pyfisher
pyfisherFisher forecasting for cosmological surveyspyfisher is a python package for calculating Fisher matrices and for forecasting parameter uncertainties for cosmological surveys.🟥Version 2 is a total revamp, so if you’re used to what this software looked like before November 2020, you should switch to the ``legacy`` branch.While the new version does not (yet) provide an interface for CMB lensing noise curves with iterative
delensing like the old one did, it has a simplified API, lots of pre-calculated
Fishers, and a tool to reparametrize into a σ8  parameterization.Free software: BSD licenseDocumentation:https://pyfisher.readthedocs.io.InstallationInstall in two steps:Git clone the repositorycdinto the repository and runpip install-e.--user.The latter step just copies symbolic links to the relevant modules into a directory (managed by pip) that is in your python path.Once this is done, you should be able to do things likeimportpyfisherfrom anywhere on your system.Basic UsageSee and runpython tests/test_lensing.pyto reproduce Planck constraints and get a feel for how to use this package.History2.0.0 (2020-11-22)First release on PyPI.
Package: pyFission
pyFissionDescriptionpyFission syncs tables/schemas across databases as defined in theconfigs/fission.pyfile.
Ifsrc_tableandsrc_schemaargs are not provided, it will sync all tables and schemas specified in thefission.pyconfig file by summoning multiple bash commands in parallel.Thepyfissionmodule has 2 methods of syncing tables -full: truncate + full sync of table, as name suggestsincremental: syncs changes based on primary key and replication key provided infission.pyconfig filepyFission automatically detects and builds the schema definition for tables, including nested and repeated fields
for JSON-like schemas e.g:- BigQuery. Also, pyFission patches tables automatically if any new fields are added.Getting startedUsageModifyconfigs/custom_config.pyandconfigs/fission.pywith DB creds and sync config respectivelyAdd service account private key files/secrets tosecrets_storagedir if needed$python-mpyfission--src[]--dest[]sync--help
usage:__main__.pypyfission[-h][--src_tableSRC_TABLE][--src_schemaSRC_SCHEMA][--src_dbSRC_DB][--dest_tableDEST_TABLE][--dest_schemaDEST_SCHEMA][--dest_dbDEST_DB][--method{full,incremental}][--out_format{csv,json}]optionalarguments:-h,--helpshowthishelpmessageandexit--src_tableSRC_TABLEOverridestabledefinitionfrompyfissionconfigs--src_schemaSRC_SCHEMAOverridesschemadefinitionfrompyfissionconfigs--src_dbSRC_DBOverridesdatabasedefinitionfrompyfissionconfigs--dest_tableDEST_TABLEOverridestabledefinitionfrompyfissionconfigs--dest_schemaDEST_SCHEMAOverridesschemadefinitionfrompyfissionconfigs--dest_dbDEST_DBOverridesdatabasedefinitionfrompyfissionconfigs--method{full,incremental}MethodofReplication--out_format{csv,json}FormatofoutputfilesRecommendedout_format:jsonfor BigQuerycsvfor othersTo sync a particular table - specify the src_schema and src_table argsdest_tablewill have same name assrc_tableunless explicitly specifieddest_schemawill be set fromfission.pyconfig file'sfission_destdictsrc_dbanddest_dbwill derived fromsrcanddestpython-mpyfission--src[]--dest[]sync--src_table[]--src_schema[]--out_format[]To sync an entire DB - only providesrcanddestargspython-mpyfission--src[]--dest[]sync--out_format[]InstallationpipinstallpyfissionContribution/Local installationClone the repo$gitclonehttps://github.com/nishantnath/pyfission.gitChange the working directory to fission$cdpyfissionInstall python3 and the requirements if they don't exist$pipinstall-rrequirements.txt
Package: pyfit
pyfitpyfitis a minimalist neural networks library written from scratch in Python for educational purposes.OverviewThis project aims to:demonstrateautomatic differentiation, a core concept of modern Deep Learning frameworks likePyTorchandTensorFlow;define a simple API for training neural nets, somehow mimickingPyTorch IgniteandKeras;follow good coding practices, includingtype annotationsand unit tests.This material is used in the Machine Learning course taught atENSC.ENSEIRB-MATMECAandIOGS. See alsoAcknowledgments.DemonstrationThedemo notebookshowcases whatpyfitis all about.FeaturesAutograd engine [source|tests]Neural networks API [source|tests]Metrics [source|tests]Optimizers [source|tests]Data utilities [source|tests]Training API [source|tests]Development NotesChecking the codepyfituses the following tools:blackfor code formatting.pylintandmypyfor linting.pytestfor testing.Run the following commands in project root folder to check the codebase.>python-mpylint./pyfit# linting (including type checks)>python-mmypy.# type checks only>python-mpytest# test suiteUploading the package to PyPI>pythonsetup.pysdistbdist_wheel
>python-mtwineuploaddist/*--skip-existing
Package: py-fitbit
Python bindings of Fitbit WebAPIFeaturesTODORequirementsTODOInstallationYou can installPython bindings of Fitbit WebAPIviapipfromPyPI:$pipinstallpy-fitbitUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Python bindings of Fitbit WebAPIis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: pyfive
pyfive : A pure Python HDF5 file readerpyfive is an open source library for reading HDF5 files written using
pure Python (no C extensions). The package is still in development and not all
features of HDF5 files are supported. For a more mature Python library for
read and writing HDF5 files, tryh5py.pyfive aims to support the same API ash5pyfor reading files. Cases where a
file uses a feature that is supported byh5pybut not pyfive are considered
bug and should be reported on theissue tracker. Writing HDF5 is not a goal
of pyfive and portions of the API which apply only to writing will not be
implemented.Dependenciespyfive is tested to work under Python 2.7 and 3.5.  It should also work
with Python 3.3 and 3.4.The only dependencies to run the software besides Python is NumPy.Installpyfive can be installed using pip using the command:pip install pyfiveconda package are also available fromconda-forgewhich can be installed:conda install -c conda-forge pyfiveTo install from source in your home directory use:python setup.py install --userThe library can also be imported directly from the source directory.DevelopmentgitYou can check out the latest pyfive souces with the command:git clone https://github.com/jjhelmus/pyfive.gittestingpyfive comes with a test suite in thetestsdirectory.  These tests can be
exercised using the commandsnosetestsfrom the root directory assuming thenosepackage is installed.
Package: pyfivetran
PyFivetranA simple Python wrapper around the Fivetran REST API.InstallationpipinstallpyfivetranUsagefrompyfivetranimportFivetranClientftran=FivetranClient(api_key,api_secret)# create endpoint objectsconnector_endpoint=ftran.connector_endpointcertificate_endpoint=ftran.certificate_endpointFor more examples, see theexamplesdirectory.Developmentpipinstallpoetry

gitclonehttps://github.com/kharigardner/pyfivetran.gitcdpyfivetran

poetryinstall
poetryinstall--withdev# run testspytesttests# create feature branchgitcheckout-bfeature/my-featureContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT. Fivetran API is subject to licensing, usage, and other terms and conditions not covered by this project. For more information, see theFivetran API documentation.
Package: pyfix
pyfix is a framework for writing and executing automated tests including unittests, integration tests or acceptance
tests. pyfix provides capabilities similar to other tools (such as unittest) but does not follow the xUnit semantics
to write tests.pyfix Principalspyfix aims to make tests easy to read and understand while it encourages the use of accepted software design principles
such as favor composition over inheritance. pyfix also tries to reduce the amount of syntactic “waste” that some other
frameworks suffer from (i.e. putting self in front of almost everything).Linkspyfix Github repository <https://github.com/pyclectic/pyfix>
Package: pyFixedWidthDataFile
# Fixed Width Data File Creator
This is a simple library for creating fixed-width text data files or text files (txt or csv) separated by a certain separator character.You can use it to exchange data between APIS and other applications.## InstallationTo install the package, just run the command below:pip install pyFixedWidthDataFile## UsageInstantiate the class:from pyFixedWidthDataFile import FWDataFile
app = FWDataFile(path_to_specs_folder, optional_separator)path_to_specs_folder: Path to the folder containing theSpecs Files;optional_separator: Separation character between fields (optional)Specs Files: Files, JSON standard, with specifications of the fields contained in the lines (records).see example in tests/specsOpen the record with “{”, enter the name clause, it is mandatory. Open the list of objects of type field with “fields {”, enter the id of the field and enter the characteristics of the field.# Characteristics List
* name: (required) name of the field
* start_pos: (required) starting position
* end_pos: (required) end position
* format: (required) field type, which can be:
> 1. alpha: alphanumeric, text
> 2. num: numeric (integer, floating point)
* default: (optional) default value of the field, if there is no default value the field will not be filled with spaces, even if it is numeric.
* decimals: (optional) only for numeric fields, number of decimal places
* ignore: (optional) field to be ignored
* required: (optional) mandatory field
* regex: (optional) regular expression operations fieldInject the lines from the file:app.append_line(“header”,cod_client=”1234”,name_client=”Alexandre Defendi”)use the result:print(app)“R000001PED1234 Alexandre Defendi       X”## LicenseThis project is under the MIT license. See the [LICENSE](LICENSE.txt) file for more details.
Package: pyfixedwidths
Easy way converting from text, list, or dict to text or list with fixed widths.The Installation>>> pip install pyfixedwidthsExamples>>> from pyfixedwidths import FixedWidthFormatter
>>> text = (
>>> "1,2,3,4\n"
>>> "11,,33,44\n"
>>> )
>>>
>>> listofdict = [
>>>     dict(name="John Doe", age=20, hobby="swim"),
>>>     dict(name="John Smith", age=100, job="teacher"),
>>> ]
>>>
>>> array = [
>>>     [1, None, 3, 4],
>>>     [11, 22, None, 44],
>>> ]
>>>>>> fw = FixedWidthFormatter()
>>> fw.from_text(text).to_text(padding=1)
>>> #=>
>>>     ("1  , 2 , 3  , 4 \n"
>>>      "11 ,   , 33 , 44\n")
>>>
>>> fw.from_text(text).to_array(padding=1)
>>> #=>
>>>     [["1  "," 2 "," 3  "," 4 "],
>>>      ["11 ","   "," 33 "," 44"],]
>>>>>> fw = FixedWidthFormatter()
>>> fw.from_array(array).to_text(padding=0)
>>> #=>
>>>     ("1 ,None,3   ,4 \n"
>>>      "11,    ,None,44\n")
>>>
>>> fw.from_array(array).to_array(padding=0)
>>> #=>
>>>     [["1 ","None","3   ","4 "],
>>>      ["11","    ","None","44"],]
>>>>>> fw = FixedWidthFormatter(schema=schema)
>>> fw.from_dict(listofdict).to_text(padding=0)
>>> #=>
>>>     ("name      ,age,hobby,job    \n"
>>>      "John Doe  ,20 ,swim ,       \n"
>>>      "John Smith,100,     ,teacher\n")
>>>
>>> fw.from_dict(listofdict).to_list(padding=0)
>>> #=>
>>>     [["name      ", "age", "hobby", "job    "],
>>>      ["John Doe  ", "20 ", "swim ", "       "],
>>>      ["John Smith", "100", "     ", "teacher"],]>>> schema = [
>>>     dict(
>>>         justification="rjust"
>>>     ),
>>>     dict(
>>>         format=":>5s"
>>>     ),
>>>     dict(),
>>>     dict(
>>>         format=":2s"
>>>     )
>>> ]
>>>
>>> fw = FixedWidthFormatter(schema=schema)
>>> fw.from_dict(listofdict).to_text(padding=2)
>>> #=>
>>>     ("      name  ,    age  ,  hobby  ,  job\n"
>>>      "  John Doe  ,     20  ,  swim   ,    \n"
>>>      "John Smith  ,    100  ,         ,  teacher\n")
>>>
>>> fw.from_dict(listofdict, headers=["hobby", "job", "location", "name"]).to_text(padding=1)
>>> #=>
>>>     (   "hobby ,     job , location , name\n"
>>>         " swim ,         ,          , John Doe\n"
>>>         "      , teacher ,          , John Smith\n")RequirementsPython 3
Package: pyfixfmt
PyFixFmtYour all-in-one python formatter. Able to be called on files or strings to format and standarize a Python file.Removes unused imports (withautoflake), sorts imports (withisort), and then formats the code (withblack). It will respect your project'spyproject.tomlconfiguration for those tools.Meant to make formatting of python code as deterministic as sanely possible.InstructionsTo install:pip install pyfixfmtTo run:# file-glob can be either a single file name or a normal unix glob.
python -m pyfixfmt --file-glob <your file glob here> --verboseConfiguration:# in pyproject.toml
[tool.formatters.python]
# Do not change anything about imports in these files
ignore_import_changes = []
# Do not remove imports that are unused in these files
do_not_remove_imports = []DevelopingDevelop withPoetry.Build withpoetry build, and publish withpoetry publish.
Package: pyfixm
Aboutpyfixm is a library that contains Python wrappers for theFIXMXML Schemas,
plus theUS NAS extensionfor the FAA. Currently the library is built for
FIXM v3.0, as this is what the FAA uses to publish data throughSWIM.Usageimportpyfixmxml=pyfixm.parse("./fixm_file.xml")Building pyfixm manuallyTo buildpyfixmeither use the suppledbuild-pyfixmPyCharm run
configuration or by manually runningscripts/build.py. Both methods build
the library within a Docker image and then extract the built library to./pyfixmon the host computer. Reminder to install Docker if you haven’t
already.LicenseThis project has two licenses. Because really what this repository creates is a
transpilation of the FIXM XSD files, the generated library is treated as a
distribution of the upstream and not a novel codebase and assumes no further
copyright with the built library. Both components are licensed under the BSD
3-Clause, but the copyright holder is different.Source RepoThepyfixmlibrary-generating source code is licensed under the BSD 3-Clause
license.Generated LibraryThe generated library (the part that gets published to PyPI) is licensed under
the same license as the upstream FIXM XSD files. Note that the copyright is
attributed to the FIXM copyright holders to avoid any copyright complexities.
Package: pyfixture
py-fixturepyteststyle fixturesFeatures:fixturedecorator to mark function as fixture factoryFixture Scope- unit of work for fixture value evaluationFixture Context- Fixture Scope is also a context managerValue Cache- Fixture value is evaluated only once per scopeFixture Factory Argument Replacement- Invoke fixture factory with replaced argumentsGenerator Fixture- Generator function could be used as fixture factoryScope tear down- through.finish()method. Individual fixtures are torn down in reverse order of their evaluationGenerator fixture tear downDetect recursive evaluationExamplesBasic ExampleThis basic example demonstrates thefixturedecorator, fixture scope and value cache.frompyfixtureimportfixture,FixtureScope@fixturedefx():print("Evaluate x")return1scope=FixtureScope()scope.get_fixture_value('x')# Evaluate x# 1scope.get_fixture_value('x')# 1Advanced ExampleThis example build on the basic example by demostrating additional features:Fixture factory argument replacementFixture Context - fixture scope using context managerGenerator fixtureScope tear downGenerator fixture tear downfrompyfixtureimportfixture,FixtureScope@fixturedefx():print("Evaluate x")yield1print("Tear down x")@fixturedefy():print("Evaluate y")yield2print("Tear down y")@fixturedefz(x,y):print("Evaluate z")yieldx+yprint("Tear down z")defi_am_not_fixture(a,x,y,z):print(f"i_am_not_function: a:{a}, x:{x}, y:{y}, z:{z}")withFixtureScope()asscope:print("Get z for the first time")assertscope.get_fixture_value("z")==3print("Get z for the second time")assertscope.get_fixture_value("z")==3print("Bind a function")binded=scope.bind(i_am_not_fixture,ignore_missing=True)binded(200)print("Finish scope")# Get z for the first time# Evaluate x# Evaluate y# Evaluate z# Get z for the second time# Bind a function# i_am_not_function: a:200, x: 1, y:2, z:3# Finish scope# Tear down z# Tear down y# Tear down xFixtures can have other fixtures as parameters. Parameters are evaluated and replaced automatcally:@fixturedeftheta(z):print("Theta:{z}")return2*zwithFixtureScope()asscope:print(scope.get_fixture_value("theta"))Recursive fixture evaluation detected automatically andRecursiveFixtureEvaluationexception is raised:frompyfixtureimportfixture,FixtureScope@fixturedefone(two):pass@fixturedeftwo(three):pass@fixturedefthree(one):passwithFixtureScope()ass:s.get_fixture_value("one")Reallistic Examplefrompyfixtureimportfixture,FixtureScope@fixturedefexisting_user():user=User.objects.get_or_create(username="myuser")yielduseruser.delete()@fixture(name="given_existing_order")defexisting_order(existing_user):order=Order.objects.get_or_create(id=1,user=existing_user)yieldorderorder.delete()scope=FixtureScope()order=scope.get_fixture_value("existing_order")user=scope.get_fixture_value("user")assertorder.userisuser# ...
Package: pyfixtures
PyFixturesPyteststylefixturesoutside of Pytest.importasynciofrompathlibimportPathfrompyfixturesimportfixture,FixtureScope@fixturedeftmpdir()->path:path=Path("temp")path.mkdir()try:yieldpathfinally:path.unlink()defmk_temp_files(tmpdir:Path):tmp_file=tmpdir/"tempfile.txt"tmp_file.touch()asyncdefmain():asyncwithFixtureScope()asscope:operation=awaitscope.bind(mk_temp_files)awaitoperation()asyncio.run(main())
Package: pyfizi
Functionally-informed Z-score Imputation (FIZI)FIZI leverages functional information together with reference linkage-disequilibrium (LD) to
impute GWAS summary statistics (Z-score).This README is a working draft and will be expanded soon.InstallationThe easiest way to installfiziandpyfiziis through conda and conda-forge:conda config --add channels conda-forge
conda install pyfiziAlternatively you can use pip for installation:pip install pyfiziOr directly from the github repository:git clone git@github.com:bogdanlab/fizi.git
cd fizi
pip install .Check that FIZI was installed by typingfizi --helpIf that did not work, andpip install pyfizi --userwas specified, please check that your local user path is included in$PATHenvironment variable.--userlocation and can be appended to$PATHby executingexport PATH=`python -m site --user-base`/bin/:$PATHwhich can be saved in~/.bashrcor~/.bash_profile. To reload the environment typesource ~/.bashrcorsource ~/.bash_profiledepending where you entered it.We currently only support Python3.7+.Python2.7 and below is not supportedOverviewfizihas two main functions:mungeandimpute. Themungesubcommand is a pruned down version of the LDSC munge_sumstats software with a few bells and whistles needed for our imputation algorithm. Theimputesubcommand performs summary statistic imputation using either the functionally informed algorithm (i.e.fizi) or using only reference-LD-only algorithm (i.e. ImpG). For a full list of features please refer to the help command:fizi munge -horfizi impute -h.Imputing summary statistics using only reference LDWhen functional annotations and LDSC estimates are not provided tofizi, it will fallback to the classic ImpG
algorithm described in ref1. To impute missing summary statistics only for chromosome 1 using the ImpG algorithm
simply enter the commands1. fizi munge gwas.sumstat.gz --out cleaned.gwas
2. fizi impute cleaned.gwas.sumstat.gz plink_data_path --chr 1 --out imputed.cleaned.gwas.chr1.sumstatBy defaultfizirequires that at least 50% of SNPs to be observed for imputation at a region. This can be changed with the--min-prop PROPflag in step 2.Incorporating functional data to improve summary statistics imputationUsage consists of several steps. We outline the general workflow here when the intention to perform imputation on
chromosome 1 of our data:Munge/cleanallGWAS summary data before imputationfizi munge gwas.sumstat.gz --out cleaned.gwasPartitioning cleaned GWAS summary data into chr1 and everything else (loco-chr1).Run LDSC on locoChr to obtain tau estimatesPerform functionally-informed imputation on chr1 data using tau estimates from loco-chrSoftware and supportIf you have any questions or comments please contactnicholas.mancuso@med.usc.eduand/ormeganroytman@gmail.comFor performing various inferences using summary data from large-scale GWASs please find the following useful software:Association between predicted expression and complex trait/diseaseFUSIONEstimating local heritability or genetic correlationHESSEstimating genome-wide heritability or genetic correlationUNITYFine-mapping using summary-dataPAINTOR
Package: pyfk
AboutPyFK is the python port ofFKused to calculate the Green’s function and the synthetic waveforms for the 1D Earth model.The main features of this package are:Compute the Green’s function for the explosion, single force, and double couple source using the frequency-wavenumber method.Compute the static displacements and corresponding Green’s function.Compute the synthetic waveforms by convolving Green’s function with the seismic source.Use the seismic data format of Obspy, which is easy to perform the signal processing.And the package is unique as:all the code is written in pure python, and it’s compatible with Unix-like systems including Mac and Linux. The Windows is not supported, as the package uses the complex number in Cython, which uses the C99 standard of “complex.h” that has not been supported by the Visual Studio compiler.it uses Cython to speed up the computationally expensive part (mainly the wavenumber integration).The package has also provided three modes:Serial mode: the serial version implements the FK algorithm in Python.Parallel mode on CPU: the wavenumber integration can be paralleled by MPI.Parallel mode on GPU: the wavenumber integration can also be paralleled by CUDA on GPU.InstallationThe serial version and the parallel version on GPU can be simply installed using pip:pipinstallpyfkOr conda:conda install -c ziyixi pyfkIt’s also easy to install the MPI enabled version:PYFK_USE_MPI=1 pip install pyfk[mpi]Extra packages includingnumbaandcupywill be required to enable the GPU mode. For more details about the Installation, you can refer to the Installing part of the document.TodoThe current bugs to fix or features to provide are listed inTODO.LicensePyFK is a free software: you can redistribute it and modify it under the terms of
theApache License. A copy of this license is provided inLICENSE.
Package: pyfl
FeaturesActive python library developed specifically for the TFL APIsyncrhonousObject Orientated CodeInstallationTo install the latest and most stable version:pip install pyflTo install the development version (not recommended):pip install git+https://github.com/wotanut/pyfl.gitOr via gitgit clone https://github.com/wotanut/pyflUseful linksPyPIDocumentationDiscord ServerWatch me live stream the code here
Package: pyFLAC
A simple Pythonic interface forlibFLAC.FLAC stands for Free Lossless Audio Codec, an audio format similar to MP3, but lossless,
meaning that audio is compressed in FLAC without any loss in quality. This is similar to
how Zip works, except with FLAC you will get much better compression because it is designed
specifically for audio.pyFLAC allows you to encode and decode raw audio data directly to/from a file, or in real-time
using callbacks.InstallationYou can use pip to download and install the latest release with a single command.pip3 install pyflacNotepyFLAC depends onlibsndfile, which requires an extra install step on Linux distributions.
See theSoundFiledocumentation for more information.Supported platformsmacOS(Intel/Apple Silicon)Linux(x86_64/arm64)RPiZero/2/3/4Windows8/10/11CLIpyFLAC comes bundled with a command line tool to quickly convert between WAV and FLAC files.
For more information, print the help info.pyflac --helpNoteIf you didn’t install pyFLAC globally then the command line tool will not be installed on your PATH.
However you should still be able to access the tool withpython3 -m pyflac.