Saravanan666/pypi-org huggingface dataset:
Package: felucca
Felucca: Dependency Management for CairoFelucca helps you declare, manage and install dependencies of Cairo projects, ensuring you have the right stack everywhere.InstallationIt supports Python 3.9+:pip install feluccaIntroductionfeluccais a tool to handle Cairo contracts installation as well as its packaging levaraging Python native capabilities. Felucca usesPoetryunder the hood to handle all Python project management using thestandardizedpyproject.toml.Why?Cairo contracts development works very closely with Python for project management, dependency installation and testing. Felucca tries to simplify the process of sharing, installing and managing Cairo contracts between differents projects and working in a more natural manner where packages evolve over time and dependant projects doesn't have to upgrade Cairo contracts manually. Using Felucca's approach to leverage Python capabilties in terms of dependency management and project structure gives many advantages:Unified project structure across Cairo packages.Rapid adaptation to changes as the ecosystem evolves.Compatibility management between Cairo contracts with different Cairo versions.Effortless installation for quick usage in new packages.Traceability of Cairo packages and releases.Global availability of Cairo packages.Many more...UsageThis tool provides a set of different command to handle all the product lifecycle for dependency and package management.Cairo package project structure creationfelucca new <package_name>This command will create a project structure for Cairo packages from atemplateready to be used for development.Cairo package installationfelucca install felucca-package-exampleThis command will install the Cairo package into the project while checking Cairo compatibility, keeping traceability using thepyproject.tomlfile to save required metadata and installing the Cairo contracts into the project.Cairo package uninstallfelucca uninstall felucca-package-exampleThis command will remove the Cairo package from the project and all the related metadata.Cairo package setupfelucca setupIf you want to check if your project is ready to work as a Cairo package this command will check all the needed requirements to do so. If not properly setup it will fix it for you automatically.
Package: fem
Quick StartInteractive notebookLaunch an interactive Jupyter notebook using Binder to run and edit the examples in the documentation:InstallationTo installfemon your computer usingpip, executepipinstallfemDependencies:Fortran compiler such as gfortranLAPACK development filesOpenMP development files (for parallel computing support)Loadfemin your Python script:importfemLinksOnline documentation:http://nihcompmed.github.io/femSource code repository:https://github.com/nihcompmed/femPython package index:https://pypi.python.org/pypi/fem
Package: femagtools
Introduction to FemagtoolsFemagtools is an Open-Source Python-API for FEMAG offering following features:run Femag with a FSL script file anywhere:
locally (single and multi-core), remote (ZMQ), HT Condor, Cloud (Amazon AWS, Google Cloud), Dockerread I7/ISA7, NC, BCH/BATCH, PLT, ERG filesread and write MCV files (magnetizing curves)create a variety of plotscreate FSL files from model and calculation templates and/or user specific FSLcreate FSL files from DXFcreate and analyze symmetrical windingssizing and parameter identificationcalculate machine characteristics by using analytic machine modelsexecute parameter studies and multi-objective optimizationThe package can be used with Python 3.x on Linux, MacOS or Windows and is hosted on github:https://github.com/SEMAFORInformatik/femagtools/` where also many examples can be found in the examples directory. Contributions and feedback to this project are highly welcome.The installation can be done in the usual ways with pip:pip install femagtools[all]([all] pulls in all optional dependencies.For details see the documentationhttp://docs.semafor.ch/femagtoolsModules and ScriptsThe package provides following modules:mcv,tks,jhb,losscoeffs: handling magnetizing curves and iron losseserg,bch: read ERG, BCH/BATCH files created by FEMAGmodel,fsl: create machine and calculation modelsfemag: manage the FEMAG calculationairgap: read airgap induction file created by a previous calculationmachine: analytical machine modelswindings: create and analyze windingsgrid: running parameter variationsopt: running multi objective optimizationsplot: creating a variety of plotsdxfsl: create FSL from DXFisa7,nc: read ISA7/I7, NC (NetCDF) fileswindings: create and analyze windingsforcedens: read PLT filesamazon,google,condor,multiproc: engines for the calculation in Cloud and HTCondor environments or locally using multiple coresThe following modules can be executed as script:bch: print content in json format if invoked with a BCH/BATCH file as argumentbchxml: produces an XML file when invoked with a BCH/BATCH file as argumentplot: produces a graphical report of a BCH/BATCH fileairgap: prints the base harmonic amplitude of the radial component of the airgap induction when invoked with the file name of an airgap induction filemcv: print content in json format if invoked with a MC/MCV file as argumentdxfsl/conv: show geometry or create fsl from dxfUsageFor many applications it is sufficient to import femagtools:importfemagtoolsThe version can be checked with:femagtools.__version__'1.0.nn'
Package: femail
femailPython package which supports sending mail through different kinds of API'spepipostfrom femail.pepipost import Client

# initialize client
c = Client(api_key, "codewarsnl@pepisandbox.com", "codewarsnl")

# Send mail
c.send_mail(to=["codewars.nl@gmail.com"], subject="test", body="Hello this is a test from a python library made by https://codewars.nl")

# Render jinja template and send mail
c.send_html_mail(to=["codewars.nl@gmail.com"], subject="test jinja", jinja_template_absolute_path="D:\\Private\\femail\\test.html", what="world!")
Package: fempy
Welcome to fempy!Fempy is a pure python cross platform package for solving systems of PDEs by finite element method. It provides abstractions for dealing with discretized domains, fields on these domains, weak forms constructed with the fields and for solving the resulting systems of equations. Linear, non linear and time dependent problems can be solved with fempy.InstallationBest way to install fempy is by usingpip:pip install -U fempyThe only dependencies required are numpy and scipy. However for automatic meshing and preview of results you will need alsogmshexecutable in your path. You may choose to install it withpipas well:pip install -U gmsh-sdkTestingRun all tests by:python -m fempy.tests.runtestsYou can also specify subpackages, e.g:python -m fempy.tests.runtests domainExamples can be executed similarely as:python -m fempy.examples.elasticNote, that most examples need gmsh and a running display.
Package: femtetutils
This library provides a Python interface that extends the functionality of Femtet. This library does not change the functionality or license of Femtet itself. This library requires a legally licensed copy of Femtet.MIT LicenseCopyright (c) 2023 Murata Manufactureing Co., Ltd. All Rights Reserved.Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: femto-admin
Femto AdminSimplest fastest minimal ASGI CRUD Admin panel for Tortoise ORM modelsIt's generating fully native async auto  zero config one line appRequirementsPython >= 3.9INSTALLpipinstallfemto-adminRun your appDescribe your db models with Tortoise ORM inmodels.pymodulefromtortoiseimportfieldsfromtortoise_apiimportModelclassUser(Model):id:int=fields.IntField(pk=True)name:str=fields.CharField(255,unique=True,null=False)posts:fields.ReverseRelation["Post"]classPost(Model):id:int=fields.IntField(pk=True)text:str=fields.CharField(4095)user:User=fields.ForeignKeyField('models.User',related_name='posts')_name='text'# `_name` sets the attr for displaying related Post instace inside User (default='name')Write run scriptmain.py: pass your models module in Api app:fromfemto_adminimportAdminimportmodelsapp=Admin().start(models)SetDB_URLenv variable in.envfileRun it:uvicornmain:appOr you can just fork Completed minimal runnable example fromsample apps.And voila:You have menu with all your models at root app route:http://127.0.0.1:8000Made with ❤ on top of theStarlette,TortoiseORM,TortoiseAPI.
Package: femtocrux
femtocruxCompiler API for the Femotsense Sparse Processing Unit (SPU).This package drives compilation of machine learning models to SPU binaries, as well as simulation of those binaries on SPU hardware.The package itself is a thin Python wrapper communicating to the actual compiler / simulator via gRPC.Supported ML model representations:Femtosense Quantized IR (FQIR)InstallationYou will need to have python3.10and Docker installed.
Install Docker by followingthese instructions.femtocrux is available on PyPI viapip install femtocruxBasic UsageManagedCompilerClientManagedCompilerClientis the recommended way to use femtocrux within a context manager.fromfemtocruximportManagedCompilerClient,FQIRModel# fqir_graph = ... # Assuming we have an FQIR graph using fmot# inputs = ...     # Assuming we have numpy array inputs to the modelfqir_model=FQIRModel(fqir_graph,batch_dim=0,sequence_dim=1)withManagedCompilerClient()asclient:# simulate execution, view power, energy, and latency metricssimulator=client.simulate(fqir_model)outputs,metrics=simulator.simulate(inputs)# compile the model to a bitfilebitstream=client.compile(fqir_model)withopen('my_bitfile.zip','wb')asf:f.write(bitstream)The bitfile can be used to generate program files to run on the SPU, usingfemtodriverpubCompilerClientCompilerClientis another interface to the compiler. This will be deprecated in future releases, so we recommend usingManagedCompilerClient.fromfemtocruximportCompilerClient,FQIRModel# fqir_graph = ... # Assuming we have an FQIR graph using fmot# inputs = ...     # Assuming we have numpy array inputs to the modelfqir_model=FQIRModel(fqir_graph,batch_dim=0,sequence_dim=1)client=CompilerClient()# simulate execution, view power, energy, and latency metricssimulator=client.simulate(fqir_model)outputs,metrics=simulator.simulate(inputs)# compile the model to a bitfilebitstream=client.compile(fqir_model)withopen('my_bitfile.zip','wb')asf:f.write(bitstream)# close the client (important to avoid background docker containers that continue running)client.close()
Package: femtoflow
FemtoFlowfemtoflowis a Python package that enables pruning and quantization of TensorFlow models for optimized deployment to Femtosense's SPU (Sparse Processing Unit). The package provides a straightforward and flexible interface for reducing model size and complexity while maintaining high-performance inference on the SPU.FeaturesPruning:Reduce model size by removing unimportant connections and neurons from your TensorFlow model.Quantization:Lower the precision of weights and activations to reduce memory requirements and computational costs while preserving model accuracy.Getting StartedYou can installfemtoflowusingpip:pip install femtoflowDocumentationDetailed documentation forfemtoflow, including tutorials, API reference, and examples, can be found on the official website:https://femtoflow.femtosense.ai
Package: femtosphinx
femtosphinxA repository providing some documentation for how to use sphinx.Also provides theexecute_codesphinx extension, which can be enabled with: (indocs/conf.py)extensions=[...'femtosphinx.execute_code',...]And then used with the.. exec::and.. exec_as_bullets::directives.Getting startedInstall sphinxpip install sphinxRead thisgetting started guide.Take a look at ourintro guide.Start generating documentation!
Package: femwell
FemwellFinite element based simulation tool for integrated circuits, electric and photonic!
The documentation is lagging behind the state of code,
so there's several features for which there are only examples in the code.You can try out the examples in the browser!Hover the rocket at the top on the example pages and click live code!(Might take some time to load)FeaturesPhotonic eigenmode solverPeriodic photonic eigenmode solverElectric eigenmode solverThermal mode solver (static and transient)Coulomb solverPossible SimulationsEigenmodes of waveguides and determining their effective refractive indexCoupling between neighboring waveguidesEigenmodes of bent waveguidesPropagation loss of circular bends and mode mismatch loss with straight waveguidesCalculation of the group velocity and its dispersionCalculation of overlap-integrals and confinement-factorsBragg grating cellsGrating coupler cellsEigenmode of a coaxial cable and its specific impedanceEigenmodes of electric transmission lines
and determining their propagation constant (in work)Static thermal profilesTransient thermal behaviorStatic electric fieldsOverlap integrals between waveguide modesOverlap integral between a waveguide mode and a fiber modeCoupled mode theory - coupling between adjacent waveguidesHeat based photonic phase shiftersPockels based photonic phase shiftersPN junction depletion modulator (analytical)Something missing? Feel free to open anissue:)ContributorsHelge Gehring (Google, WWU Münster)Simon Bilodeau (Google, Princeton University)Joaquin Matres (Google)Marc de Cea Falco (Google, Massachusetts Institute of Technology)Lodovico Rossi (Princeton University)Doris Reiter (Dortmund University)Yannick Augenstein (Google, Karlsruhe Institute of Technology)Niko Savola (Google, Aalto University)Happy about every form of contribution -
pull requests, feature requests, issues, questions, ... :)
Package: fen2pil
fen2pilConvert Forsyth–Edwards Notation (FEN) to a 2D chessboard PIL image.fromfen2pilimportdrawfen="r1bqkb1r/pppp1ppp/2n2n2/4p3/2B1P3/3P1N2/PPP2PPP/RNBQ1RK1 w Qkq - 0 1"pil_image=draw.transform_fen_pil(fen=fen,board_size=480,light_color=(255,253,208),dark_color=(76,153,0))pil_image.show()
Package: fenapack
FENaPack is a package implementing preconditioners for Navier-Stokes
problem using FEniCS and PETSc packages. In particular, variants of PCD
(pressure-convection-diffussion) preconditioner from[1],[2]are
implemented.[1]Elman H. C., Silvester D. J., Wathen A. J.,Finite Elements and Fast
Iterative Solvers: With Application in Incompressible Fluid Dynamics.
Oxford University Press 2005. 2nd edition 2014.[2]Olshanskii M. A., Vassilevski Y. V.,Pressure Schur complement
preconditioners for the discrete Oseen problem.
SIAM J. Sci. Comput., 29(6), 2686-2704. 2007.UsageTo use FENaPack matching version of FEniCS (version 2019.1.0)
compiled with PETSc, petsc4py and mpi4py is needed. Note that
FENaPack uses same version numbering as FEniCS and follows
its release schedule with a short lag.To install FENaPack from source do:pip3 install [--user|--prefix=...] [-e] .in the source/repository root dir.  Editable install using-eallows to use FENaPack directly from source directory while
editing it which is suitable for development.You can install latest FENaPack release form PyPI:pip3 install [--user|--prefix=...] fenapackor install latest development version from Github:pip3 install [--user|--prefix=...] git+https://github.com/blechta/fenapackTo start experimenting:cd demo/navier-stokes-pcd
python3 demo_navier-stokes-pcd.py --help
python3 demo_navier-stokes-pcd.py [opts]
mpirun -n 16 python3 demo_navier-stokes-pcd.py [opts]Full documentation is available athttps://fenapack.readthedocs.io/.AuthorsJan Blechta <blechta@karlin.mff.cuni.cz>Martin Řehoř <rehor@karlin.mff.cuni.cz>LicenseFENaPack is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.FENaPack is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public License
along with FENaPack. If not, see <http://www.gnu.org/licenses/>.AcknowledgementThis work was supported by The Ministry of Education, Youth and Sports from the
Large Infrastructures for Research, Experimental Development and Innovations
project „IT4Innovations National Supercomputing Center – LM2015070“.LinksHomepagehttps://github.com/blechta/fenapackTestinghttps://circleci.com/gh/blechta/fenapackDocumentationhttps://fenapack.readthedocs.io/Bug reportshttps://github.com/blechta/fenapack/issuesPyPI homehttps://pypi.org/project/fenapack
Package: fenbux
FenbuXA Simple Probalistic Distribution Library in JAXfenbu(分布, pronounce like: /fen'bu:/)-X is a simple probalistic distribution library in JAX. The library is encouraged byDistributions.jl. In fenbux, We provide you:A simple and easy-to-use interface likeDistributions.jlPyTree input/outputMultiple dispatch for different distributions based onplum-dispatchAll jax feautures (vmap, pmap, jit, autograd etc.)SeedocumentExamplesStatistics of Distributions 🤔importjax.numpyasjnpfromfenbuximportvariance,skewness,meanfromfenbux.univariateimportNormalμ={'a':jnp.array([1.,2.,3.]),'b':jnp.array([4.,5.,6.])}σ={'a':jnp.array([4.,5.,6.]),'b':jnp.array([7.,8.,9.])}dist=Normal(μ,σ)mean(dist)# {'a': Array([1., 2., 3.], dtype=float32), 'b': Array([4., 5., 6.], dtype=float32)}variance(dist)# {'a': Array([16., 25., 36.], dtype=float32), 'b': Array([49., 64., 81.], dtype=float32)}skewness(dist)# {'a': Array([0., 0., 0.], dtype=float32), 'b': Array([0., 0., 0.], dtype=float32)}Random Variables Generationimportjax.randomasjrfromfenbuximportrandfromfenbux.univariateimportNormalkey=jr.PRNGKey(0)x={'a':{'c':{'d':{'e':1.}}}}y={'a':{'c':{'d':{'e':1.}}}}dist=Normal(x,y)rand(dist,key,shape=(3,))# {'a': {'c': {'d': {'e': Array([1.6248107 , 0.69599575, 0.10169095], dtype=float32)}}}}Evaluations of Distribution 👩‍🎓CDF, PDF, and more...importjax.numpyasjnpfromfenbuximportcdf,logpdffromfenbux.univariateimportNormalμ=jnp.array([1.,2.,3.])σ=jnp.array([4.,5.,6.])dist=Normal(μ,σ)cdf(dist,jnp.array([1.,2.,3.]))# Array([0.5, 0.5, 0.5], dtype=float32)logpdf(dist,jnp.array([1.,2.,3.]))# Array([-2.305233 , -2.5283763, -2.7106981], dtype=float32)Nested Transformations of Distribution 🤖importfenbuxasfbximportjax.numpyasjnpfromfenbux.univariateimportNormal# truncate and censor and affined=Normal(0,1)fbx.affine(fbx.censor(fbx.truncate(d,0,1),0,1),0,1)fbx.logpdf(d,0.5)Array(-1.0439385, dtype=float32)Compatible with JAX transformations 😃vmapimportjax.numpyasjnpfromjaximportvmapfromfenbuximportlogpdffromfenbux.univariateimportNormaldist=Normal({'a':jnp.zeros((2,3))},{'a':jnp.ones((2,3,5))})# each batch shape is (2, 3)x=jnp.zeros((2,3,5))# claim use_batch=True to use vmapvmap(logpdf,in_axes=(Normal(None,{'a':2},use_batch=True),2))(dist,x)gradimportjax.numpyasjnpfromjaximportjit,gradfromfenbuximportlogpdffromfenbux.univariateimportNormaldist=Normal(0.,1.)grad(logpdf)(dist,0.)Speed 🔦importnumpyasnpfromscipy.statsimportnormfromjaximportjitfromfenbuximportlogpdf,randfromfenbux.univariateimportNormalfromtensorflow_probability.substrates.jax.distributionsimportNormalasNormal2dist=Normal(0,1)dist2=Normal2(0,1)dist3=norm(0,1)x=np.random.normal(size=100000)%timeitjit(logpdf)(dist,x).block_until_ready()%timeitjit(dist2.log_prob)(x).block_until_ready()%timeitdist3.logpdf(x)51.2 µs ± 1.47 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
11.1 ms ± 176 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
1.12 ms ± 20.1 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)InstallationInstall on your local device.gitclonehttps://github.com/JiaYaobo/fenbux.git
pipinstall-e.Install from PyPI.pipinstallfenbuxReferenceDistributions.jlEquinox
Package: fenbux-plum-dispatch
Plum: Multiple Dispatch in PythonEverybody likes multiple dispatch, just like everybody likes plums.The design philosophy of Plum is to provide an implementation of multiple dispatch that is Pythonic, yet close to howJuliadoes it.See here for a comparison between Plum,multipledispatch, andmultimethod.Note:Plum 2 is now powered byBeartype!
If you notice any issues with the new release, please open an issue.InstallationPlum requires Python 3.8 or higher.pipinstallplum-dispatchDocumentationSeehere.What's This?Plum brings your type annotations to life:fromnumbersimportNumberfromplumimportdispatch@dispatchdeff(x:str):return"This is a string!"@dispatchdeff(x:int):return"This is an integer!"@dispatchdeff(x:Number):return"This is a general number, but I don't know which type.">>>f("1")'This is a string!'>>>f(1)'This is an integer!'>>>f(1.0)'This is a number, but I don'tknowwhichtype.'>>>f(object())NotFoundLookupError:Forfunction`f`,`(<objectobjectat0x7fb528458190>,)`couldnotberesolved.This also works for multiple arguments, enabling some neat design patterns:fromnumbersimportNumber,Real,Rationalfromplumimportdispatch@dispatchdefmultiply(x:Number,y:Number):return"Performing fallback implementation of multiplication..."@dispatchdefmultiply(x:Real,y:Real):return"Performing specialised implementation for reals..."@dispatchdefmultiply(x:Rational,y:Rational):return"Performing specialised implementation for rationals...">>>multiply(1,1)'Performing specialised implementation for rationals...'>>>multiply(1.0,1.0)'Performing specialised implementation for reals...'>>>multiply(1j,1j)'Performing fallback implementation of multiplication...'>>>multiply(1,1.0)# For mixed types, it automatically chooses the right optimisation!'Performing specialised implementation for reals...'