Saravanan666/pypi-org huggingface dataset:
Package: optipyzer
Optipyzeroptipyzeris a lightweight python package that interfaces the core opitpyzer server for use inside python programs. It lets you codon optimize any DNA or protein sequences inside python by providing a convenient API to construct and make requests to the optimization server. It returns the results as python objects for downstream use.Installationpip install optipyzerQuick StartTo get started, simply create anAPIinstance, and start making requests:importoptipyzerapi=optipyzer.API()gblock="ATGGCCCTTTAA"result=api.optimize(seq=dna_seq,seq_type="dna",weights={"human":2,"mouse":1},)print(result['optimized_sd'])More InformationFor a more detailed tutorial, please visit thedocs
Package: optiQs
A python library simulating optical circuits.stokes formalismThe relationship of the Stokes parameters S0, S1, S2, S3 to intensity and polarization ellipse parameters is shown by:S0 = I
S1 = I*p*cos(2φ)cos(2χ)
S2 = I*p*sin(2φ)sin(2χ)
S3 = I*p*sin(2χ)where:
I : intensity of the polarizer
p : degree of polarization
φ : angle between the major axis of the ellipse and the x-axis
χ : ellipticity angleStokes vector is given by:S = [S0,S1,S2,S3]Apart from getting output for specific values there are four common states which are horizontally polarized, vertically polarized, polarized at 45 and -45 degrees.Example codeimport stokes_formalism from qwanta
print(stokes_formalism.diagonal_positive()) # polarized at 45 degrees
print(stokes_formalism.diagonal_negative()) # polarized at 45 degrees
print(stokes_formalism.horizontal()) # horizontally polarized
print(stokes_formalism.vertical()) # vertically polarized
Package: optirx
A pure Python library to receive motion capture data from OptiTrack
Streaming Engine.OptiTrack is a line of motion capture products by NaturalPoint. Their
software can broadcast motion capture data via a documented binary
protocol. It is supposed to be used together with the proprietary
NatNet SDK, which, unfortunately, is not available for Python, nor
cannot be used with free toolchains (GCC, Clang). OptiRX is based on
the direct depacketization example from the SDK and does not use
NatNet SDK.Installpip install optirxCompatibilityTracking Tools 2.5.0; Motive 1.5.x (NatNet 2.5.0.0), 1.7.x (NatNet 2.7.0.0), 1.9.0 (NatNet 2.9.0.0).UsageAssuming that Tracking Tools or Motion runs on the same machine and
broadcasting is enabled on the local network interface (not the loopback),
this code receives and prints all data frames:import optirx as rx

dsock = rx.mkdatasock()
version = (2, 9, 0, 0)  # NatNet version to use
while True:
    data = dsock.recv(rx.MAX_PACKETSIZE)
    packet = rx.unpack(data, version=version)
    if type(packet) is rx.SenderData:
        version = packet.natnet_version
    print packetAlternativesuse VRPN streaming protocol.use Matlab or Microsoft toolchains.use PyNatNet and NatNet SDKLicenseMIT
Package: optisherpa-agents
LLM agents is a python package that contains a collection of Language Model (LLM) agents specialized in different
domains involves
several key components. Each agent within the package would be tailored to its specific field, such as economics, energy
analysis, geopolitical analysis, and transportation supply chain analysis. Below is an elaboration on the skeleton
structure of such a software package:Package Structure/llm_agents(Root Directory)Contains all the components of the package./agentsThis directory contains the implementation of each LLM agent./economisteconomist_agent.py: Implementation of the LLM agent specialized in economics./energy_analystenergy_analyst_agent.py: Implementation of the LLM agent specialized in energy analysis./geopolitical_analystgeopolitical_analyst_agent.py: Implementation of the LLM agent specialized in geopolitical analysis./transportation_supply_chain_analysttransportation_supply_chain_analyst_agent.py: Implementation of the LLM agent specialized in transportation and supply chain analysis.
Package: optisorl
Copyright Peter Bengtsson,mail@peterbe.com, 2015-2016License: BSDAbout optisorlsorl-thumbnailis a
great Django library that takes your stored images and automatically
convert them into desired sized thumbnails and store them with nice
names in theMEDIA_ROOT. The problem is that the engines that do
the resizing often doesn’t do an amazing job of optimizing them.
Usually optimizing an image means carefully deleting things the human
eye can’t notice anyway. This becomes incredibly relevant when the
thumbnail you create is so small in resolution that the user really
stands very little chance to notice.This package, is a pluggable backend tosorl-thumbnailthat
attempts to do a good job of optimizing the generated thumbnail just
right after it has been written to disk.InstallationFirst, simplypip install optisorl.Then add, in your Django settings:THUMBNAIL_BACKEND = 'optisorl.backend.OptimizingThumbnailBackend'Then review the sections below about being prepared for PNGs, GIFs and JPEGs.Optimizing PNGsoptisorluses a binary calledpngquantwhich is a command line tool that do lossy compression of PNG images
and supports alpha transparency.pngquantis
BSD licensed. It’s easy to install on most systems. For examplebrew install pngquantorapt-getinstall pngquant.What happens is that whenoptisorlnotices that a thumbnail was
created it (and stored inMEDIA_ROOT) it then takes that file and
executespngquantsomething like this:pngquant -o /path/file.tmp.png --skip-if-larger -- /path/file.pngNote the--skip-if-largerwhich means that if the thumbnail is really
really small already the resulting optimization might not be any better
and it thus omits doing an optimization.If you want to override the location of the executablepngquantyou
can set this setting for example:# in settings.py or equivalentPNGQUANT_LOCATION='/opt/special/bin/pngquant2.0'Optimizing GIFsoptisorlusesgifsiclewith
level 3 optimization.gifsicleis GPL licensed but use is not
restricted by a license. To install it usebrew install gifsicleorapt-getinstall gifsicle.To override where thegifsicleexecutable is located you can set
in your settings:# in settings.py or equivalentGIFSICLE_LOCATION='/opt/special/bin/gifsicle'If you want to disable all optimization of GIFs just setGIFSICLE_LOCATION(in yoursettings.py) toNoneorFalse.Optimizing JPEGsoptisorlusesmozjpegto
optimize JPEGs. It’s a great fit because it almost never reduces
the quality such that human eyes can notice it. Especially when the
thumbnails are relatively small. The command that we use to executemozjpeglooks like this:mozjpeg -outfile DESTINATION -optimise SOURCEYou can override where the executable is by setting:# in settings.py or equivalentMOZJPEG_LOCATION='/my/bin/mozjpeg'For an example of what kind of results you can get withmozjpegsee this blog post:Examples of mozjpeg savings.
Also see blog postmozjpeg installation and sample.LimitationsHelp is most welcome. At the moment…Does not support S3 storageUnable to NOT optimize images in run-timeNot possible to override certainpngquantparametersNot possible to override certaingifsicleparametersNot possible to override certainmozjpegparameters
Package: opti-ssr
This python package provides the necessary tools to use anOptiTrackoptical tracking system for different applications of theSoundScapeRenderer(SSR)
including listener position and orientation tracking in local sound field synthesis.It contains several modules including a module to connect to the OptiTrack system (opti_client) and
a seperate one to connect to and control instances of the SSR (ssr_client).
The module that connects these aforementioned ones and implements sequence and desired functionality is also part of the package (bridges).Note that theoptirx1.10 library is included here with only minor changes from the original source and
that the modules ssr_client and opti_client respectively are designed
to be used independently in other projects as well.Documentation:http://opti-ssr.rtfd.io/Source code:https://github.com/OptiTools/opti_ssrPython Package Index:http://pypi.python.org/pypi/opti_ssr/Example files to set up the SSR:https://github.com/OptiTools/opti_ssr-examplesLicense:MIT – see the fileLICENSEfor details.InstallationAside fromPythonitself,NumPyandpyquaternionare needed. It should work with both Python3 as well as Python2.The easiest way to install this package is usingpipto download the latest release fromPyPi:pip install opti_ssrUsageTo use opti_ssr you can use a demo function like the basic one below.
Simply instantiate the necessary class objects according to the given parameters and start the thread in the class that contains the functionality.
Ready-to-use demo functions to demonstrate head orientation tracking in binaural synthesis or
listener tracking in local sound field synthesis are available at the github repository.
The SoundScape Renderer has to be started prior to opti_ssr.import opti_ssr

def demo(ssr_ip, ssr_port, opti_unicast_ip, opti_multicast_ip, opti_port, ssr_end_message):
    optitrack = opti_ssr.OptiTrackClient(opti_unicast_ip, opti_multicast_ip, opti_port)
    ssr = opti_ssr.SSRClient(ssr_ip, ssr_port, ssr_end_message)
    headtracker = opti_ssr.HeadTracker(optitrack, ssr)
    headtracker.start()

if __name__ == "__main__":
    demo()
Package: optlite
OPT LiteOnline Python Tutor(OPT) is a popular virtual learning tool that provides interactive visualisation of program execution in a browser without login. However, such a tool is not easy to maintain because serving allowing the public to run programs in a server without login incurs high computational cost in addition to security risks.This project makes OPT serverless, i.e., usuable offline without a server. Python programs are run by the browser usingpyodide. Teachers can enable more python packages/functions than the original setup without worring about network attacks. For online exam, students may also use the tool to debug programs without worry of network outage.The project is in development phase. Using it in production without understanding the source code isnot recommended.
Package: optlnls
optlnlsUseful python functions for x-ray optics simulations and metrology developed in LNLS, CNPEMAbout hybrid:Hybrid documentation and license can be foundHERE.Authors:Sergio A. Lordano Luiz (sergiolordano2@gmail.com)Artur C. Pinto (artur.pinto@lnls.br)Humberto Rigamonti Jr. (humberto.junior@lnls.br)João Pedro I. Astolfo (joao.astolfo@lnls.br)Bernd C. Meyer
Package: optmagic
optmagicversion 1.1.0This project enables you to create simple command line interfaces starting
with a python class, or a python function that you want to expose directly to the shell.It contains functionality which has not yet all been fully documented. Stay tuned.Similar projectsargparseinvokeclickdocoptWhy not use one of those?Ideally, the programmer should not have to specify anything extra than what the class or function already contains to expose its functionality. None of these other packages strive to accomplish that goal likeoptmagicdoes, as you can see in the following comparative examples.TODODemoTODOInstallingTo install theoptmagicpackage, simply type the following command on your terminal:$ pip3 install optmagicDependenciesThe project depends on the following module for parsing the docstrings automatically:docstring_parserIf you want to run the test suite foroptmagicyou will also need the following extra libraries:pytestmatplotlibpbs3Extra documentationMore documentation is available at:http://xapple.github.io/optmagic/optmagicThis documentation is simply generated with:$ pdoc3 --html --output-dir docs --force optmagic
Package: optmanage
Flexible option managers, supporting options with default values, static type hints, runtime type checking, and custom runtime validation logic.ContentsInstallUsageAPIContributingLicenseInstallYou can install the latest release fromPyPIas follows:$pipinstall--upgradeoptmanageUsageCustom option manager classes can be created by subclassingOptionManagerand using theOptiondescriptor to set options.
An option manager object can then be obtained by instantiating the option manager class:fromoptmanageimportOption,OptionManagerclassMyOptions(OptionManager):""" Options of some library. """validate=Option(bool,True)""" Whether to validate arguments to functions and methods. """eq_atol=Option(float,1e-8,lambdax:x>=0)""" Absolute tolerance used for equality comparisons."""scaling:Option(Mapping[Literal["x","y","z"],float],{"x":1.0,"y":2.0,"z":1.0},lambdascaling:all(v>=0forvinscaling.values()))""" Scaling for coordinate axes used in plots.  """options=MyOptions()Each option takes a default value, a type, and an optional validator function:validate=Option(bool,True)#     option type ^^^^  ^^^^ default valueeq_atol=Option(float,1e-8,lambdax:x>=0)#           optional validator ^^^^^^^^^^^^^^^^Any type supported by thetyping-validationlibrary can be used for options, includingPEP 484type hints:scaling:Option(Mapping[Literal["x","y","z"],float],# <- type hints supported{"x":1.0,"y":2.0,"z":1.0},lambdascaling:all(v>=0forvinscaling.values()))Options can be accessed and set like attributes of theoptionsobject:print(options.scaling)# {'x': 1.0, 'y': 2.0, 'z': 1.0}options.scaling={"x":2.5,"y":1.5,"z":1.0}print(options.scaling)# {'x': 2.5, 'y': 1.5, 'z': 1.0}It is possible to set multiple options simultaneously using thesetmethod of theoptionsobject:options.set(validate=False,eq_atol=1e-3)print(options.validate)# Falseprint(options.eq_atol)# 0.001It is also possible to use the options object as a context manager, for temporary option setting:withoptions(validate=False,eq_atol=1e-3):print(options.validate)# Falseprint(options.eq_atol)# 0.001print(options.validate)# Trueprint(options.eq_atol)# 0.00000001All options can be reset to their default values by using theOptionManager.resetmethod of theoptionsobject:options.set(validate=False,eq_atol=1e-3)print(options.validate)# Falseprint(options.eq_atol)# 0.001options.reset()print(options.validate)# Trueprint(options.eq_atol)# 0.00000001An individual option can be reset to its default value by using theOption.resetmethod of theOptionobject, accessed from the option manager class:options.set(validate=False,eq_atol=1e-3)print(options.validate)# Falseprint(options.eq_atol)# 0.001MyOptions.eq_atol.reset(options)# resets 'eq_atol' on the 'options' objectprint(options.validate)# Trueprint(options.eq_atol)# 0.001APIFull documentation is available athttps://optmanage.readthedocs.io/ContributingThis project is currently in private development. Public contribution guidelines are available atCONTRIBUTING.md.LicenseMIT © Hashberg Ltd.
Package: optmatch
optmatch- Library to allow an easy and effective parsing of command line options.Full documentation:https://coderazzi.net/python/optmatchoptmatchis based on expressing the actions -with all options and related flags-
that are supported, instead of just listing all possible argument flags.For example:class Example(OptionMatcher):@optsetdef handle_common_flag(self,mail_option):…@optmatcherdef handle_compression(self, filename,compress_flag=False):…@optmatcher(flags=’verbose’, options=’mode’)def handle(self, filename, verbose=False, mode=’simple’, where=None):…In this example:It is defined a common flag (–mail)It is defined an action, supporting a –compress flag which is False by default,  and requiring a filename parameterIt is defined a second action, supporting a –verbose flag and a –mode option, requiring one or two file locations.
Package: opto
opto is a Python module that allows you to controlOptotune focus
tunable
lensesusing
theOptotune Lens Driver
4.
Tested with anOptotune
EL-10-30.ExamplesOpens the serial port, connects to the Optotune, sets the lens current
to 50 mA, and closes the serial port, gently returning the lens to 0 mA
current:fromoptoimportOptoo=Opto(port='/dev/cu.usbmodem1411')o.connect()o.current(50.0)o.close(soft_close=True)Alternatively, here we use thewithstatement to create a sinusoidal
transition from minimum to maximum current and back:fromoptoimportOptoimportnumpyasnpimporttimewithOpto(port='/dev/cu.usbmodem1411')aso:current_low=o.current_lower()current_high=o.current_upper()current_delta=current_high-current_lowforiinnp.linspace(0,2*np.pi,1000):o.current(np.sin(i)*current_delta+current_low)time.sleep(0.01)InstallationUsepipto install from github:pip install git+https://github.com/OrganicIrradiation/opto.gitor clone the package using git:git clone https://github.com/OrganicIrradiation/opto.gitRequirementsRequirespySerial
Package: optobench
Benchmark Functions for OptimizationFast benchmarks for testing numerical optimization methods with Python interface.This project provides a Python module with C++ implementations of benchmark functions for optimization.
These functions often are the most time-consuming part of evaluating new
optimization methods, so any improvements to this part help speed-up such
research.Quick Startimportoptobenchasobxs=[.1,.2,.3,.4,.5]print(ob.michalewicz(xs))importnumpyasnpnxs=np.array(xs)print(ob.michalewicz(nxs))nxss=np.array([[0.4,0.31,0.445,0.218,0.581,0.171,0.532,0.24],[0.265,0.43,0.568,0.144,0.4,0.333,0.188,0.402],[0.191,0.366,0.234,0.272,0.307,0.436,0.203,0.361],[0.262,0.254,0.407,0.254,0.254,0.335,0.169,0.265],[0.362,0.097,0.167,0.269,0.395,0.659,0.234,0.127]])print(ob.michalewicz(nxss))RequirementsPython 3.8numpy>=1.18g++ / clang with support for C++17Installation# First, load your python environment# NextpipinstalloptobenchFrom source# First, load your python environment# Nextmake# build loadable module in a local directorymakeinstall# build module and install in current environmentmaketest# run testsList of functionsx ackley
x alpine
x bohachevsky1
x bohachevsky2
x bohachevsky3
x bukin_f6
x cross_in_tray
x dejong5
x eggholder
x gramacy_lee
x holder_table
x langermann
x levy
x levy13
x six_hump_camel_back
x deceptive3
x drop_wave
x easom
x penalty1
x griewank
x goldstein_price
x axis_parallel_hyperellipsoid
x rotated_hyperellipsoid
x sum_powers
x sum_squares # alias for axis_parallel_hyperellipsoid
x trid
x michalewicz
x perm0db
x permdb
x noncontinuous_rastrigin
x rastrigin
x parabola # alias for sphere
x rosenbrock
x schaffers_f2
x schaffers_f4
x schaffers_f6
x schwefels
x schwefels_p222
x shubert
x sphere
x step
x tripod
x trefethen4
x three_hump_camel_back
x dixon_price
x beale
x branin
x colville
x styblinski_tang
x powell
x shekel
x forrester
x hartmann_3d
x hartmann_4d
x hartmann_6d
x booth
x matyas
x mccormick
x power_sum
x zakharovContributionsAfter forking the repo and cloning it locally, usemake && make test.make testruns thetestit.shscript, which evaluates functions and dumps the result tosanity-test-instance.logfile.
Next, that result is compared against golden results insanity-test-golden.log.When your changes are ready and golden data updated, submit a pull request.ReferencesK.Voss 2016pythOPT: A problem-solving environment for optimization methodsMomin Jamil, Xin-She Yang 2013A Literature Survey of Benchmark Functions For Global Optimization ProblemsOptimization Test Problems, SFUExtending PythonC++ cmathCppCoreGuidelinesGoogle C++ Style Guide
Package: optoConfig96
optoConfig-96 - Interactive configuration of experiments using the optoPlate-96DocumentationoptoConfig-96 lives onGitHub. You will find further instructions and documentation over there!If optoConfig-96 was useful to you, please consider citing the paper:Thomas, OS, Hörner, M & Weber, W: A graphical user interface to design high-throughput optogenetic experiments with the optoPlate-96.Nat Protoc(2020).https://doi.org/10.1038/s41596-020-0349-x
Package: optoid
OptoidA helper library named optoid.Installpip install optoidUsagefrom optoid import Commander

commander = Commander()

# You need to attach once.
commander.attach()
print("success to attach")

commander.send_command("lis;len;lis;lis;lis")
print("success to send command")Developpip install pywin32
pip install wheel
pip install twinepython setup.py sdist
python setup.py bdist_wheeltwine upload --repository pypitest dist/*
python -m pip install --index-url https://test.pypi.org/simple/ optoidtwine upload --repository pypi dist/*Develop (wine)wine64 cmd
.venv\\Scripts\activate
python -m example.tryout
Package: optom-tools
Optom Tools ⚠️ Under develepment ⚠️Getting StartedInstall withpipor your other favourite package manager (e.g.pipenvorpoetry).pipinstalloptom-toolsSimple Example>>>fromoptom_toolsimportPrescription>>>prescription=Prescription.parse("+1.00/-2.00x180")>>>prescription.transpose()>>>str(prescription)"-1.00 / +2.00 x 90"DocsComprehensive documentation can be found here:https://shivan-s.github.io/optom-toolsContributionYes, please. I'd love some help on this.
Package: optopy
Welcome tooptopyDocs|Installation|CiteAt present,optopyis a clone oftvopt, but in the future it will include more functionalities, with the goal of delivering a module suited to the benchmarking of bothstaticanddynamicoptimization algorithms.tvoptis a prototyping and benchmarking Python framework for time-varying (or online) optimization. The framework is modular,
and provides different tools for modeling dynamic optimization problems and to solve them with a wide range of well known
algorithms.The documentation is availablehere.Installationoptopyworks on Python 3.7 and depends on: numpy, scipy.pip installationpip install optopyCiteSeetvoptand relative reference:@article{bastianello_tvopt_2020,
	title = {tvopt: {A} {Python} {Framework} for {Time}-{Varying} {Optimization}},
	url = {http://arxiv.org/abs/2011.07119},
	journal = {arXiv:2011.07119 [cs, math]},
	author = {Bastianello, Nicola},
	year = {2020}
}Authoroptopyis developed byNicola Bastianello
Package: optotrak
Read data exported from NDI First Principles. Only tested for use with Optotrak
sensors.InstallationPip:pip install optotrakConda:conda install -c otaithleigh optotrakUsageRead the example file into a pandas DataFrame:>>> from optotrak import load_optotrak
>>> load_optotrak('test_optotrak.tsv')
                      x           y            z
Frame Name
1     Beam1  486.618958 -560.735657 -2618.344971
      Beam2  349.383820 -561.470093 -2552.003174
2     Beam1  486.617706 -560.736206 -2618.349365
      Beam2  349.381195 -561.467651 -2551.989258
3     Beam1  486.620819 -560.732178 -2618.347412
      Beam2  349.382477 -561.469910 -2551.998535
4     Beam1  486.624023 -560.735962 -2618.353760
      Beam2  349.385376 -561.468994 -2551.997070
5     Beam1  486.622925 -560.734924 -2618.353760
      Beam2  349.384094 -561.467957 -2551.995605
6     Beam1  486.618439 -560.733887 -2618.344971
      Beam2  349.382568 -561.467041 -2551.992432
7     Beam1  486.617798 -560.736206 -2618.344238
      Beam2  349.382965 -561.469482 -2551.994141
8     Beam1  486.620270 -560.736145 -2618.348877
      Beam2  349.382446 -561.466797 -2551.987305
9     Beam1  486.622437 -560.734375 -2618.348389
      Beam2  349.384796 -561.470032 -2551.996826
10    Beam1  486.623932 -560.736755 -2618.351318
      Beam2  349.382874 -561.468628 -2551.993896
Package: optparse-pretty
This module provides two help formatters foroptparse. They provide
terser and more customizable option formatting in comparison to the
default help formatter. Refer to the documentation for examples and
usage instructions.Documentation:http://optparse-pretty.readthedocs.org/en/latest/Development:https://github.com/gvalkov/optparse-prettyPackage:http://pypi.python.org/pypi/optparse-prettyChangelog:https://github.com/gvalkov/optparse-pretty/releases