Saravanan666/pypi-org huggingface dataset:
Package: ode-parameter-estimator
ODE system parameter estimatorThis is a little python package to provide convenience functions that use thescipycapabilities for ODE systems and curve fitting in order to estimate the correct parameters of the ODE system for a given set of data.UsageIn the fashion ofscipy.integrate.solve_ivp, we have an ODE system
$$
\frac{dy}{dt} = f(t,y,p)
$$
where $t$ is the independent parameter, $y$ a vector function and $p$ a parameter list. If we numerically solve the system withsolve_ivpwe would get a time arraysolution.tand a matrixsolution.ywhose rows are the trayectories of the components of $y$.TheEstimatorProblemclass requires the data to be in this form: a time array, a samples array in row order, and the derivative function. For example, here is theLorenz chaotic oscillator:$$
\frac{\mathrm{d}x}{\mathrm{d}t} = \sigma (y - x), \qquad
\frac{\mathrm{d}y}{\mathrm{d}t} = x (\rho - z) - y, \qquad
\frac{\mathrm{d}z}{\mathrm{d}t} = x y - \beta z.
$$deflorenz(t,Y,*args):σ,ρ,β=argsx,y,z=Yreturnnp.array([σ*(y-x),# dx/dtx*(ρ-z)-y,# dy/dtx*y-β*z# dz/dt])along with some data in a file, by columnst, x, y, z#   t       x       y        z0.000001.001001.001001.001000.067421.347342.328780.953510.134832.345944.393421.174070.202254.240417.943612.225410.269667.5020113.507095.74678...which can be imported and visualized liket,*Y=np.loadtxt("samples.dat",unpack=True)Y=np.array(Y)plt.plot(t,Y.T,"o",fillstyle='none')The parameter fitting is done by simplyproblem=EstimationProblem(t,Y,lorenz)problem.fit([9,28,2])# initial guesswhich will hopefully display a message saying that the fit was successful. That success is heavily dependant of the quality of the initial guess, specially in chaotic or ill-behaved systems.We can test the solution with the help of theEstimationProblem.outputmethod, which evals the solution on the requested times:ts=np.linspace(0,2,200)Ys=problem.output(ts)plt.plot(t,Y.T,"o",fillstyle='none')plt.gca().set_prop_cycle(None)# reset color cycleplt.plot(ts,Ys.T)More examplesOn [test/systems.py] are implementations of:Radioactive decayHousekeeping gene expressionLotka-VolterraSIR epidemicsDamped coupled oscillatorsLorenz-Fetter-Hamilton oscillatorAll of them are tested withclean solutionsand withnoisy solutionsto emulate experimental data.Similar toolsThere is, in Julia,a whole ecosystem of packagesthat implements several methods to do "dynamic data analysis". Not only there is a package namedDiffEqParamEstim.jl, but there are also packages that find parts of the ODE system using scientific machine-learning.TO DOImplement dimension checking to avoid obscure error traces.Finish documentation. Again.Give the option to also fit the initial conditions. Thisshouldbe possible, as the first data point should be a good initial guess.Understand better the fail conditions, and provide more information.
Package: ode-python
ode-pythonThis is yet another Python binding ofOpen Dynamics Engine (ODE).pip install ode-pythonPlease note that ODE and Drawstuff are not included in this library.To install ODE on debian for example:apt install libode-devCode samples are available intestdirectory.LicenseThe MIT License (MIT)Copyright (c) 2020 QooskyPermission 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: odesf
String format function of ODEsThis package provides a simple function - transform a list of ODEs in string format into a string of a function in Python/C++.Examples are as follows.For pythonTo transform a list of ODE strings into function string format:the left hand side must be written with derivitive formd()/d()fromodesfimporteq_to_pyfunc_stringstiff_equation=['dy/dt = z + t','dz/dt = -100 * y * t']funcstr=eq_to_pyfunc_string(stiff_equation)print(funcstr)>>"def func(_x_, _y_, _f_): _f_[0] = _y_[1] + _x_; _f_[1] = -100 * _y_[0] * _x_;"If constants exist, a list of constant equations must be passed over:The constant variable name at the left hand side must be the same as in ODE stringsfromodesfimporteq_to_pyfunc_stringlorenz_equation_strs=['dx/dt = sigma * (y - x)','dy/dt = rho * x - y - x * z','dz/dt = x * y - beta * z']lorenz_constants=['sigma = 10e0','rho = 28e0','beta = 8e0 / 3e0']funcstr=eq_to_pyfunc_string(lorenz_equation_strs,lorenz_constants)print(funcstr)>>"def func(_x_, _y_, _f_): sigma = 10e0; rho = 28e0; beta = 8e0 / 3e0;  _f_[0] = sigma * (_y_[1] - _y_[0]); _f_[1] = rho * _y_[0] - _y_[1] - _y_[0] * _y_[2]; _f_[2] = _y_[0] * _y_[1] - beta * _y_[2];"For C++Unlike for python, the result is a tuple:function string in.cppformatfunction head string in.hformatfromodesfimporteq_to_cfunc_stringstiff_equation=['dy/dt = z + t','dz/dt = -100 * y * t']funcstr,funch=eq_to_cfunc_string(stiff_equation)print(funcstr)print(funch)>>"Function str: void template_func(double _x_, double _y_[], double _f_[]) { _f_[0] = _y_[1] + _x_; _f_[1] = -100 * _y_[0] * _x_; }">>"Head str:  void template_func(double _x_, double _y_[], double _f_[]);"
Package: odesli
python-odesliOdesli/Songlink API wrapper for python.Currently using versionv1-alpha.1of the Odesli API.InstallationpipinstallodesliFrom sourceInstall the PyPI packagebuild:pipinstallbuildThen (from the root of the repo):pipinstalldist/*.whlUsageConvert Spotify link to Tidal and Youtube Music links:fromodesli.OdesliimportOdesliodesli=Odesli()result=odesli.getByUrl('https://open.spotify.com/track/1jJci4qxiYcOHhQR247rEU')print(result.songsByProvider['tidal'].linksByPlatform['tidal'])print(result.songsByProvider['youtube'].linksByPlatform['youtubeMusic'])For more information refer to the officialOdesli API documentation.Projects using this wrapperodesli-cli
Package: odesli-cli
odesli-cliCLI client for the Odesli/Songlink API.Installationpipinstallodesli-cliFrom sourceInstall the PyPI packagebuild:pipinstallbuildThen (from the root of the repo):pipinstalldist/*.whlSample usages:Get information on a song by it's urlodesli-cli'{URL}'allConvert current Spotify track to Tidal link and copy it to the X clipboard (Linux only)current_spotify="$(qdbusorg.mpris.MediaPlayer2.spotify/org/mpris/MediaPlayer2org.mpris.MediaPlayer2.Player.Metadata|grepxesam:url|awk'{print $2}')"odesli-cli"$current_spotify"--providertidallink|xclip-selectionclipboardOpen Tidal, Spotify, Deezer, etc. links directly in the Spotify app (The coolest one, Linux only)For this functionality one needs to hack a bit more. I have it all set up with my Linux dofiles, so trust me, it works.
Just some key points to make it work:Create a shell script that can handle all sorts of http(s) links and set it as the mime default.Match Tidal, etc. links, convert them with this tool and play them withqdbus org.mpris.MediaPlayer2.spotify /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.OpenUri "{URI}".Match Spotify links and play them directly with above command (note that you need to convert the url to a uri in both cases).If you need additional information don't hesitate to contact me via mail. I haven't tried the dbus command for playing with the Tidal or Deezer apps, but it may work for them in the same fashion.
Package: odesolver
ODESolverGeneral suite of ODE solversSource code:https://github.com/ComputationalPhysiology/odesolverDocumentation:https://computationalphysiology.github.io/odesolverInstallYou can install the library with pippython3 -m pip install odesolverGetting startedTBWLicenseMITNeed help or having issuesPlease submit anissue
Package: odetoolbox
Choosing the optimal solver for systems of ordinary differential equations (ODEs) is a critical step in dynamical systems simulation. ODE-toolbox is a Python package that assists in solver benchmarking, and recommends solvers on the basis of a set of user-configurable heuristics. For all dynamical equations that admit an analytic solution, ODE-toolbox generates propagator matrices that allow the solution to be calculated at machine precision. For all others, first-order update expressions are returned based on the Jacobian matrix.In addition to continuous dynamics, discrete events can be used to model instantaneous changes in system state, such as a neuronal action potential. These can be generated by the system under test as well as applied as external stimuli, making ODE-toolbox particularly well-suited for applications in computational neuroscience.
Package: odevio
The easy way to setup, build & release flutter apps for iOS on Linux, Windows and MacOSOdevio is a tool to help developers setup and release their Flutter apps on iOS.
Thanks for checking it out.A tool for developers by developersInstallationOdevio is a CLI utility developed in Python. It is easily installed with
pip.pip install odevioUsageTo start using Odevio simply runodevioin your console.Start by creating an accountodevio signupYour Odevio account is now created and you can either start a build machine in configuration mode : to configure XCode or test your app in the iOS simulator.odevio build start --build-type configurationOr you can build an IPA or release your app by linking your Apple Developer Account to Odevio and creating an app identifierodevio apple add --apple-id APPLE_TEAM_ID --name TEXT --key-id APPLE_KEY_ID --issuer-id APPLE_ISSUER_ID --private-key LOCATION_APPLE_PRIVATE_KEY
odevio app mk --name MY_APP_NAME --bundle-id COM.COMPANY.APP_NAMETo create the IPA to install on a physical device for testing purposesodevio build start --build-type ad-hoc
odevio build ipaTo publish directly to the App Storeodevio build start --build-type publicationYour build failed ? No worries, you can check the logs withodevio build logsDocumentationAll documentation is in thedocsdirectory and online athttps://odevio-cli.readthedocs.io/.
If you are getting started this is how we recommend you use the docs :First read ourinstallation instructions.Next, check how tosetup your app with Odevio at and build your Flutter app to iOS.Finally, if you want to know every option Odevio has to offer check ourreference guideAboutOur mission is to reduce the time it takes to setup, build and release Flutter
apps on iOS to the bare minimum.The tool allows developers working alone or in teams and on
multiple OS (Linux, Windows, MacOS) to build and publish their apps easily
to the app store.What can Odevio be used for ?It allows you to setup the XCode project on a remote MacOS machine if you do not own one.It manages common iOS specific settings for your team : certificates, devices, provisioning profiles, bundle IDs, Xcode configuration files, …It builds your Flutter app on remote iOS machines.It hosts the iOS app artifacts or publish them to the App Store.ContributingThank you for considering contributing to Odevio. The main purpose of this repository is to continue evolving Odevio to make Flutter developer’s lives easier.Please report improvements, bugs and issues to Github’s issue tracker.
Pull requests linked to open issues are even more appreciated.Odevio’s GitHub issue tracker is not intended to provide help or support.
For that check out ourdiscord.We are also thrilled to receive a variety of other contributions including:Documentation updates, enhancements, designs, or bugfixes.Spelling or grammar fixes.Blogging, speaking about, or creating tutorials about Odevio.Giving Odevio a Github star is much appreciated by our team ! Sharing our project with other Flutter developers is too :)
Package: odeViz
odeViz: (or as I use to say: ode - visualization)0. Contact:If you change the code, improve this project, fix bugs, or just have comments,
feel free to contact me…André Dietrich:dietrich@ivs.cs.uni-magdeburg.deWebsite:http://eos.cs.ovgu.de/en/crew/dietrich1. Preface:I wrote this simple library, because I was fed up with dealing with the visualization for every ode-simulation. All geometrical information are allready within the simulation, so why was it not done automatically.2. Requirements:Open Dynamics Engine:http://www.ode.orgDownload the current version, compile it or use binary-packages.PyODE:http://pyode.sourceforge.netThis is the ode-interface for Python, it also contains the xode-project, which enables the definition of ode-simulations with XML. See the ReadMe for further
installation information.Visualization Toolkit (VTK):http://www.vtk.orgDownload VTK if you haven’t insalled it yet and compile it with Python support. See also ReadMe for further installation information.Additional:If you are using Linux as I do (Ubuntu), nearly all of these tools and libraries can be installed from precompiled versions. But for xode you will have to download PyODE fromhttp://pyode.sourceforge.net.3. Install:Usingpip:$ pip install odeVizFrom a tarball:$ python setup.py install4. Running the examples:I put two examples in this project, one (tutorial3.py) was taken from the PyODE-tutorial. In fact it is the same, I just removed all OpenGL-functionality. The second example (test.py) shows, how easy it is to define a simulation for ode with an XML document (see test.xml). To run this example you will have to use xode.For further explanation, have a look at our tutorial at:http://www.aizac.info/projects/ode-viz
Package: odevlib
ODevLibPyPi:https://pypi.org/project/odevlib/Opinionated O.dev Django helper library.Current features are:OModel— custom model with handy fields included and built-in history using Simple History.OModelSerializer/OModelCreateSerializer— serializers for OModel that handle handy fields.OViewSet— custom viewset that reiterates on Django built-in viewsets.OModelViewSet— like the above, but includes all REST methods (auto-generated).And many more!Project statusThe library is in active use/development by O.dev backend team. Currently, the API is not stable and may change from
release to release, so please pin versions when including dependency.The nature of the library (internal use for project development) implies that no strict roadmap exists, however, it
is planned to stabilize API, so it may only be changed during major version release.
Package: odfdo
odfdoPython library for OpenDocument format (ODF)odfdois a Python3 library implementing the ISO/IEC 26300 OpenDocument Format
standard.Project:https://github.com/jdum/odfdoAuthor:jerome.dumonteil@gmail.comLicense:
Apache License, Version 2.0odfdois a derivative work of the formerlpod-pythonproject.InstallationInstallation from Pypi (recommended):pipinstallodfdoInstallation from sources (requiring setuptools):pipinstall.After installation from sources, you can check everything is working (some requirements:pytest, Pillow, ...):pytestThe tests should run for a few seconds or minutes and issue no error.Usagefrom odfdo import Document, Paragraph

doc = Document('text')
doc.body.append(Paragraph("Hello world!"))
doc.save("hello.odt")tl;dr'Intended Audience :: Developers'DocumentationThere is no detailed documentation or tutorial, but:therecipesfolder contains more than 50 working sample scripts,thedocfolder contains an auto generated documentation.When installing odfdo, 5 scripts are installed:odfdo-diff: show adiffbetween two .odt document.odfdo-folder: convert standard ODF file to folder and files, and reverse.odfdo-show: dump text from an ODF file to the standard output, and optionally styles and meta informations.odfdo-styles: command line interface tool to manipulate styles of ODF files.odfdo-replace: find a pattern (regex) in an ODF file and replace by some string.odfdo-highlight: highlight the text matching a pattern (regex) in an ODF file.About styles: the best way to apply style is by merging styles from a template
document into your generated document (Seeodfdo-stylesscript).
Styles are a complex matter in ODF, so trying to generate styles programmatically
is not recommended.Limitationsodfdois intended to facilitate the generation of ODF documents,
nevertheless a basic knowledge of the ODF format is necessary.ODF document rendering can vary greatly from software to software. Especially the
"styles" of the document allow an adaptation of the rendering for a particular
software.The best (only ?) way to apply style is by merging styles from a template
document into your generated document.Related projectI you work on .ods files (spreadsheet), you may be interested by these scripts that
use this library to parse/generate .ods files:https://github.com/jdum/odsgeneratorandhttps://github.com/jdum/odsparsatorChanges from former lpod librarylpod-pythonwas written in 2009-2010 as a Python 2.x library,
see:https://github.com/lpod/lpod-pythonodfdois an adaptation of this former project.odfdomain changes fromlpod:odfdorequires Python version 3.9 to 3.12. For Python 3.6 to 3.8 see previous releases.API change: more pythonic.include recipes.use Apache 2.0 license.
Package: odfpy
Odfpy is a library to read and write OpenDocument v. 1.2 files.
The main focus has been to prevent the programmer from creating invalid
documents. It has checks that raise an exception if the programmer adds
an invalid element, adds an attribute unknown to the grammar, forgets to
add a required attribute or adds text to an element that doesn’t allow it.These checks and the API itself were generated from the RelaxNG
schema, and then hand-edited. Therefore the API is complete and can
handle all ODF constructions.In addition to the API, there are a few scripts:csv2odf - Create OpenDocument spreadsheet from comma separated valuesmailodf - Email ODF file as HTML archiveodf2xhtml - Convert ODF to (X)HTMLodf2mht - Convert ODF to HTML archiveodf2xml - Create OpenDocument XML file from OD? packageodfimgimport - Import external imagesodflint - Check ODF file for problemsodfmeta - List or change the metadata of an ODF fileodfoutline - Show outline of OpenDocumentodfuserfield - List or change the user-field declarations in an ODF filexml2odf - Create OD? package from OpenDocument in XML formThe source code is athttps://github.com/eea/odfpyVisithttps://github.com/eea/odfpy/wikifor documentation and examples.The code athttps://joinup.ec.europa.eu/software/odfpy/homeis obsolete.
Package: odfsvn
ContentsIntroductionQuick exampleInstallationIntroductionODFSVN is a set of tools that allow you to manageODFdocuments in
asubversionrepository. There are several reasons that make this a
very useful thing to do:it allows you to use all features of a version control system: all
changes are archived along with change notes, making it possible
to roll back to previous versions, see who made what changes and why,
etc.it makes it possible to have multiple people sharing their changes
to a document through a shared repository. That means that you
can always see all changes from all editors, update your version
to the latest revision and submit your changes. No matter where you
are, with or without access to your email, you will always be
able to share your work.For now this can be done through theodfsvncommand line tool. In the
(near) future this will also be possible through a plugin forOpenOffice.org.Quick exampleSuppose you are working on a proposal with a group of people. The proposal
is stored in a file calledproposal.odtwhich you have just created.
The first thing that you need to do is import this file into an existing
repository:$ odfsvn import -m "Simplon proposal for odf RFP" proposal.odt \
  http://code.simplon.biz/proposals/odf.odt
Commited revision 22This will have added your file to the repository. The-mparameter
was used to set the commit message for this change.You can now use theinfocommand to check the repository information
inside your file:$ odfsvn info proposal.odt
Path: proposal.odt
Type: svn
URL: http://code.simplon.biz/proposals/odf.odt
Repository UUID: 1a87ecf8-a9bc-47a4-9dc9-5f45153203cc
Revision: 22If one of your co-editors wants to work on this proposal he must first
retrieve the document using thecheckoutcommand:$ odfsvn checkout http://code.simplon.biz/proposals/odf.odt
Checked out revision 22He can now edit theodf.odtfile using his normal editors. After
making any changes he can commit them using thecommitcommand:$ odfsvn commit -m "Added estimates and initial planning" odf.odt
Changes committed.You can now update your local copy using theupdatecommand:$ odfsvn update proposal.dt
Updated to revision 23Installationodfsvn requires thesubversioncommand line toolsvn,pythonandsetuptoolsto be installed.After installing those requirements you can install odfsvn using theeasy_installcommand:easy_install odfsvnThis will install the odfsvn command and the associated python package. If
you are using a UNIX shell you may need to refresh the command cache from your
shell after doing this (hash-rorrehashgenerally).
Package: odhpy
odhpyInstallationThis package may be installed using pip from Bitbucket (requires authentication), or directly from PyPi (public), or from a .tar.gz. Examples are shown below.pipinstallgit+https://bitbucket.org/odhydrology/odhpy.gitpipinstallodhpypipinstall.\dist\odhpy-0.0.32.tar.gzUsageimportodhpy# returns the package versionodhpy.__version__# prints 'Hello world!' to the consoleodhpy.hello_world()Build and Upload to PyPiFirst build a distribution from an anaconda prompt in the root of your project, and then upload the dist to PyPi using Twine.pythonsetup.pysdisttwineuploaddist\odhpy-0.0.32.tar.gzAs of Nov 2023, PyPi uses an API token instead of a conventional password. You can still use Twine, but the username is "token", and password is the API token which is very long string starting with "pypi-". Check for API tokens in your email.username=__token__password=pypi-#####################################################################################Unit TestsWARNING: Run unit tests from an anaconda environment with compatable dependencies!Install the nose2 test-runner framework. Then from the root project folder run the nose2 module. This will automatically find and run tests in any modules named "test_*".pipinstallnose2python-mnose2LicenseNone.