Saravanan666/pypi-org huggingface dataset:
Package: opentf-tools-nightly
opentf-toolsThis package is part of the OpenTestFactory initiative.OverviewThis package contains utility scripts to facilitate the configuration and usage of the
OpenTestFactory's runtime environment.The package documentation is part of theOpenTestFactory orchestratordocumentation, in theToolssection.LicenseCopyright 2021, 2023 Henix, henix.frLicensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: opentimestamps
python-opentimestampsPython3 library for creating and verifying OpenTimestamps proofs.InstallationFrom the PyPi repository:pip3 install opentimestampsStructureSimilar to the author'spython-bitcoinlib, the codebase is split between the
consensus-criticalopentimestamps.core.*modules, and the
non-consensus-criticalopentimestamps.*modules. The distinction between the
two is whether or not changes to that code are likely to lead to permanent
incompatibilities between versions that could lead to timestamp validation
returning inconsistent results between versions.Unit testspython3 -m unittest discover -vAdditionally Travis is supported.SSL Root CertificatesOn some MacOS setups SSL certificates may be missing. The following commands
could be of use to resolve this error (the below example assumes a user is
running Python "3.7", and is using Certifi package):cd /Applications/Python\ 3.7
Install\ Certificates.command
Package: opentip
OpenTIP scannerThe script is a Python 3 client to theOpenTIP service.It can scan files and directories and provide the category (clean, malware, adware). For unknown files, it will also upload them to the service for scanning and Sandbox processing (optional).To run the script, you need to obtain a valid API key fromOpenTIPand set it with the --apikey command line switch or the OPENTIP_APIKEY environment variable.Buildingpython3 -m buildInstallationInstall the package via pip.pip3 install opentipCommand line switchesOpenTIP file scannerusage: opentip [-h] [--no-upload] [--exclude EXCLUDE] [--log LOG] [--apikey APIKEY] [--quiet] path [path ...]

Check files and directories with OpenTIP.kaspersky.com, optionally upload and scan unknown files

positional arguments:
  path               File or directory location to scan

optional arguments:
  -h, --help         show this help message and exit
  --no-upload        DO NOT upload unknown files to scan with the Sandbox, default behaviour is to upload
  --exclude EXCLUDE  Do not scan or upload the files matching the pattern
  --log LOG          Write results to the log file
  --apikey APIKEY    OpenTIP API key, received from https://opentip.kaspersky.com/token
  --quiet            Do not log clean filesIOC checkerusage: check_iocs [-h] [--apikey APIKEY] [--out OUT] type value

Check IOCS (file hashes, IP addresses, domain names, URLs using the service OpenTIP.kaspersky.com

positional arguments:
  type               hash, ip, domain, url
  value              Value of the IOC (hash, ip, domain, url, filename with the iocs)

optional arguments:
  -h, --help         show this help message and exit
  --apikey APIKEY    OpenTIP API key, received from https://opentip.kaspersky.com/token
  --out OUT, -o OUT  Write output as JSON to this filename
Package: opentisim
OpenTISimOpensourceTerminalInvestmentSimulation - Terminal investment strategy analysis, parametrically driven by changing demand scenarios.Documentation can be found:hereInstallationTo install OpenTISim, run this command in your terminal:pipinstallopentisimThis is the preferred method to install OpenTISim, as it will always install the most recent stable release.If you don not havepipinstalled, thisPython installation guidecan guide you through the process.You can read thedocumentationfor other installation methods.
Package: opentiva
opentiva is a free and open-source python module that simulates target
controlled infusions by using mathematical models relating to the
pharmacokinetic and pharmacodynamic compartment models of drugs used in
anaesthetic practice.Usage examples can be found in the examples directory.Example web app using the module can be found atopentiva.comFull documentation can be foundhereFeaturesPlasma and effect site targetingOne, two and three compartment modellingBuilt in Pk/Pd models from a range of drugsTpeak ke0 calcuationUser defined infusionsOptional k20 elimination in two compartment modellingCustomize a range of properties relating to the targetting and maintenance
methodsInstallationInstall opentiva by running:pip install opentivaContributeIssue Tracker:github.com/opentiva/opentiva/issuesSource Code:github.com/opentiva/opentivaSupportIf you are having issues, please let us know via github oropentiva@jpselby.co.uk.DonateSupport opentiva by donating to:Buy me a coffeeDisclaimeropentiva is for informational, research and educational purposes only.
The pharmacokinetic/ pharmacodynamics are all obtained from medical
literature and infusions resulting from these can vary widely.
The user assumes all risks from the use of this application for clinical
purposes.LicenseThe project is licensed under the MIT license.
Package: opentmi-client
Python Client library for OpenTMIThis is the Python client library forOpenTMI.installationTo install, simply usepip:$ pip install --upgrade opentmi-clientSee theDevelopers Guideif you want to develop this library.Command Line InterfaceLibrary provides Command line Interface to communicate with OpenTMI -backend$ opentmi --help
usage: opentmi [-h] [-v] [-s] [--host HOST] [--user USER]
               [--password PASSWORD] [--token TOKEN]
               [--token_service TOKEN_SERVICE] [-p PORT]
               <subcommand> ...

optional arguments:
  -h, --help            show this help message and exit
  -v                    verbose level... repeat up to three times.
  -s, --silent          Silent - only errors will be printed
  --host HOST           OpenTMI host, default: localhost
  --user USER           username
  --password PASSWORD   password
  --token TOKEN         Authentication token
  --token_service TOKEN_SERVICE
                        Optional authentication service
  -p PORT, --port PORT  OpenTMI port

subcommand:
  <subcommand>          sub-command help
    version             Display version information
    list                List something
    store               Create somethingexample:opentmi --host localhost --port 3000 --list --testcases 1Python APIfrom opentmi_client import OpenTmiClient, Result, Event
client = Client("https://127.0.0.1")
client.login_with_access_token("my-github-access-token")

# post result
result = Result()
result.tcid = "test-case-a"
result.verdict = "pass"
client.post_result(result)

# post event
event = Event()
event.msgid = "ALLOCATED"
event.priority.level = "info",
event.ref.resource = "5697740f956cd2fd35c69062"
client.post_event(event)See more examples fromhere.Server side Result schema can be found fromhere.
and Test case schema is availablehere.notestcid-field have to be unique for each test cases.There is couple mandatory fields by default:tcidandexec.verdict. Allowed values for result verdict is:pass,fail,inconclusive,blockedanderror.upload_results()-function also create test case document if it doesn't exists in database.AuthenticationThere are multiple options to authenticate:useClient.login(<username>, <password>)useClient.login_with_access_token(<token>, [<service>])service are optional and supported values depend on server support.
By defaultgithubis in use.Use environment variables (tries login automatically when constructor is called):Using username and password:OPENTMI_USERNAMEandOPENTMI_PASSWORDorUsing github access token:OPENTMI_GITHUB_ACCESS_TOKENuse token in host likehttp://<token>@localhostLICENSEMIT
Package: openTMM
Electromagnetic wave propagation through planar stratified media (multilayer stack); the three-dimensional space is divided into layers.  The interfaces separating the layers are assumed to be perfectly planar and the layers are assumed to be isotropic and homogeneous, with a complex permittivity and permeability.  Moreover, the layers may be composed of a left-handed material (negative refractive material) and/or a right-handed material.  The implementation is suitable for the study of modern applications, e.g., Anderson localization of light and sub-wavelength imaging.For more details see our preprint,openTMMpreprint.pdf, which is distributed with the source code.  The preprint was also published in the Journal of Computational Physics (2012) 231:14, 4823-4835.http://dx.doi.org/10.1016/j.jcp.2012.03.018MAJOR CHANGES IN VERSION 0.1.0:Changed standard transfer matrix alg. to S-matrix alg.  The solution should now be numerically stable in presence of large absorption.Rewrote openTMMpreprint.pdf.  It now includes a discussion of different transfer matrix algorithms and performance comparison of python to Fortran 90/95 as well as numerical stability tests.
Package: opentnsim
OpenTNSimOpensourceTransportNetworkSimulation -  Analysis of traffic behaviour on networks for different traffic scenarios and network configurations.Documentation can be found:hereBookYou can find the opentnsim book, based on the examples in thenotebooksfolder on theopentnsim-bookwebsite.InstallationTo install OpenTNSim, run this command in your terminal:pipinstallopentnsimTo also install the extra dependencies used for testing you can use:pipinstallopentnsim[testing]This is the preferred method to install OpenTNSim, as it will always install the most recent stable release.If you don not havepipinstalled, thisPython installation guidecan guide you through the process.You can read thedocumentationfor other installation methods.TestingYou can run the unit testspytestOr you can run the notebook tests:pytest--nbmake./notebooks--nbmake-kernel=python3--ignore./notebooks/cleanup./notebooks/studentsOr you can run a specific test like this:pytest-ktest_single_engine`ExamplesThe benefit of OpenTNSim is the generic set-up. A number of examples are presented in a seperateJupyter Notebook repository. Information on how to use the notebooks is presented in that repository as well.BookBased on the examples and docs a book can be generated using the commandsmake bookand cleaned up usingmake clean-book. These commands are unix only.Code qualityCode quality is checked using sonarcloud. You can see results on thesonarcloudwebsite. For now we have disabled coverage and duplication checks. These can be enabled when we include coverage measurements and reduce duplication by optimizing the tests.OpenCLSimOpenTNSim makes use of theOpenCLSimcode. Both packages are maintained by the same team of developers. There are some differences between packages (e.g. in logging approaches), but you can use them together. We are working towards further integrating these two software packages.
Package: opentoken
opentoken-pythonOpenToken support for Python.A Python implementation of generating and parsing OpenTokens. Much of this implementation is borrowed fromnode-opentoken.https://tools.ietf.org/html/draft-smith-opentoken-02UsageCreate an opentoken string:from opentoken import OpenToken

otkapi = OpenToken("your_password")
otkapi.create_token([
    ("subject", "foobar"),
    ("key2", "val2")
])Parse an opentoken string:otkapi = OpenToken("your_password")
otkapi.parse_token("your_base64_encoded_token_string")OpenToken constructorpassword: Defaults to None.cipher_suite_id: Defaults to 2. Possible ids are 0 - no encryption, 1 - AES-256, 2 - AES-128, and 3 - 3DES-168.token_tolerance: Defaults to 120 seconds.token_lifetime: Defaults to 300 seconds.token_renewal: Defaults to 12 hours.ContributingFeel free to dive in!Open an issueor submit PRs.
Package: opentool-ai
OpenToolA common protocol for AI agent toolsExplore the docs »View Demo·Report Bug·Request FeatureOpenTool provides a simple common potocol for AI agent tools, allowing use accross different model types and frameworks.Installationpip install opentool-aiUsageLet's define a simplified Selenium web browser toolfromopentoolimportTool,action,observationfromseleniumimportwebdriverclassSeleniumBrowser(Tool):"""Selenium browser as a tool"""def__init__(self,headless:bool=True)->None:super().__init__()options=webdriver.ChromeOptions()ifheadless:options.add_argument("--headless")self.driver=webdriver.Chrome(options=options)@actiondefopen_url(self,url:str)->None:"""Open a URL in the browserArgs:url (str): URL to open"""self.driver.get(url)@actiondefclick_element(self,selector:str,selector_type:str="css_selector")->None:"""Click an element identified by a CSS selectorArgs:selector (str): CSS selectorselector_type (str, optional): Selector type. Defaults to "css_selector"."""element=self.driver.find_element(selector_type,selector)element.click()@observationdefget_html(self)->str:"""Get the entire HTML of the current page.Returns:str: Page HTML"""returnself.driver.page_sourcedefclose(self)->None:"""Close the tool"""self.driver.quit()We mark the functions to be made available to the agent as@actionif they mutate the environment, and@observationif they are read only.Now we can use this tool with an agent such as openai function callingfromopenaiimportOpenAIclient=OpenAI()browser=SeleniumBrowser()schemas=browser.json_schema()messages=[]messages.append({"role":"system","content":"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous."})messages.append({"role":"user","content":"Get the HTML for the front page of wikipedia"})headers={"Content-Type":"application/json","Authorization":"Bearer "+openai.api_key,}json_data={"model":model,"messages":messages,"tools":schemas}response=requests.post("https://api.openai.com/v1/chat/completions",headers=headers,json=json_data,)assistant_message=response.json()["choices"][0]["message"]messages.append(assistant_message)assistant_message{"role":"assistant","tool_calls":[{"id":"call_RYXaDjxpUCfWmpXU7BZEYVqS","type":"function","function":{"name":"open_url","arguments":"{\n  \"url\": \"https://wikipedia.org\"}"}},{"id":"call_TJIWlknwdoinfWEMFNss","type":"function","function":{"name":"get_html","arguments":""}}]}Then to use this actionfortoolinassistant_message["tool_calls"]:action=browser.find_action(tool["function"]["name"])args=json.loads(tool["function"]["arguments"])resp=browser.use(action,**args)Tools can be used locally or spun up on a server and used remotely (In progress)Share (In progress)Register a tool with the AgentSea hub so others can find and use it.pipinstallagentseaCreate a repo to publishagentsea create toolAdd your tool to thetool.pyin the repo, fill in theREADME.mdand add your dependencies using PoetryPublish to the hubagentsea publish .RoadmapIntegrate with langchain, babyagi, autogpt, etc
Package: opentorsion
OpenTorsion: Open-Source Backend for Torsional Vibration AnalysisOpen-source software for torsional vibration analysis. Supported features includefinite element model creation based on dimensions or datasheet specificationsnatural frequency calculationeigenmodesforced response analysistime-stepping simulationIntroductionOpenTorsion includes tools for creating shaft-line finite element models and calculation of torsional response in time or frequency domain.
Please note that the software is still in development and the authors are not able to responsibility for the functioning or effects of future changes. See the license for more information.DocumentationopenTorsion documentationQuickstartInstall openTorsion by running the commandpip install opentorsion. Folderopentorsionincludes the software. Folderexamplescontains scripts to run example powertrains and analyses.Make sure you have pip3 & pipenv installed in your system. Then simply runningpipenv installwill invoke the config files and install the necessary files in your pipenv.Two examples are found in opentorsion/examples folder.ContactThe main developers are Sampo Laine and Urho Hakonen from Arotor lab at Aalto University Finland.https://www.aalto.fi/en/industrial-internet-campus/aalto-arotor-labFor questions regarding the software please contactarotor.software@aalto.fi
Package: opentps
OpenTPSPython application for treatment planning in proton therapy, based on the MCsquare Monte Carlo dose engine.The OpenTPS application 1.0.0 contains the packages opentps-core (version 1.0.7) and opentps-gui (version 1.0.5) which are also available separately.Installating and starting OpenTPSInstall the latest version of Anaconda. Download the latest version fromhttps://www.anaconda.com/.In a conda prompt, create a new virtual environment with python 3.9 and activate it:conda create --name OpenTPS python=3.9
   conda activate OpenTPSInstall OpenTPS:pip install opentpsStart it with:opentps
Package: opentps-core
opentps-coreCore library of opentps, a Python application for treatment planning in proton therapy, based on the MCsquare Monte Carlo dose engine.Installation (Linux):Requirements are listed in pyproject.toml.
To install all required dependencies:poetry installAdditional system libraries (Ubuntu 19 or more recent):sudo apt install libmkl-rtAdditional system libraries (Ubuntu 18):cd /tmp
wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
sudo sh -c 'echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list'
sudo apt-get update
sudo apt-get install intel-mkl-64bit-2020.1-102
echo 'export LD_LIBRARY_PATH=/opt/intel/mkl/lib/intel64:$LD_LIBRARY_PATH' | sudo tee -a /etc/profile.d/mkl_lib.sh

# adapted from: http://dirk.eddelbuettel.com/blog/2018/04/15/Optional python modules:pip3 install --user tensorflow
pip3 install --user keras
pip3 install --user cupyInstallation (Windows):Note: VTK is only compatible with Python version <= 3.9. Do not use Python 3.10Install anaconda on your Windows computerOpen Anaconda Prompt (via the Anaconda application)Create a new Anaconda environment:conda create --name OpenTPS python=3.8Activate the new environment:conda activate OpenTPSInstall the following python modules:
Python modules:pip3 install --upgrade pip
pip3 install pydicom
pip3 install numpy
pip3 install scipy
pip3 install matplotlib
pip3 install Pillow
pip3 install sparse_dot_mkl
pip3 install SimpleITK
pip3 install pandas
pip3Optional python modules:pip3 install tensorflow
pip3 install keras
pip3 install cupy
Package: opentps-gui
opentps-guiGUI of opentps, a Python application for treatment planning in proton therapy, based on the MCsquare Monte Carlo dose engine.Installation (Linux):Requirements are listed in pyproject.toml.
To install all required dependencies:poetry installNote: VTK is only compatible with Python version <= 3.9. Do not use Python 3.10Installation (Windows):Note: VTK is only compatible with Python version <= 3.9. Do not use Python 3.10Install anaconda on your Windows computerOpen Anaconda Prompt (via the Anaconda application)Create a new Anaconda environment:conda create --name OpenTPS python=3.8Activate the new environment:conda activate OpenTPSInstall the following python modules:
Python modules:pip3 install --upgrade pip
pip3 install pydicom
pip3 install numpy
pip3 install scipy
pip3 install matplotlib
pip3 install Pillow
pip3 install PyQt5==5.15.7
pip3 install pyqtgraph
pip3 install sparse_dot_mkl
pip3 install vtk
pip3 install SimpleITK
pip3 install pandas
pip3Optional python modules:pip3 install tensorflow
pip3 install keras
pip3 install cupyRun:python3 main.pyor from a python script:importopentps.guiasopentps_guiopentps_gui.run()
Package: opentracing-async-instrumentation
python-opentracing-async-instrumentationA collection of asyncio instrumentation tools to enable tracing withOpenTracing API.ModuleMake sure you are running recent enough versions ofpipandsetuptools, e.g. before installing your project requirements execute this:pip install --upgrade "setuptools>=29" "pip>=9"The module name isopentracing_async_instrumentation.What's insideSupported client frameworksThe following libraries are instrumented for tracing in this module:aiobotocore— Asyncio AWS SDK for Pythonaioboto3— Asyncio AWS SDK for Python (uses aiobotocore under the hood)aiohttp- Asyncio HTTP server and clientaiomysqlLimitationsOnly Python 3.5+ is currently supported.Server instrumentationFor inbound requests a helper functionbefore_requestis provided for creating middleware for frameworks like aiohttp and possibly Tornado.A middleware is provided foraiohttp.In-process Context PropagationAs part of the OpenTracing 2.0 API, in-processSpanpropagation happens through the newly definedScopeManagerinterface.UsageThis library provides two types of instrumentation, explicit instrumentation
for server endpoints, and implicit instrumentation for client call sites.ServerServer endpoints are instrumented by creating a (or using a provided) middleware class that:initializes the specific tracer implementationwraps incoming request handlers into a method that reads the incoming
tracing info from the request and creates a new tracing Spanfromaiohttpimportwebfromopentracing_async_instrumentation.client_hooksimportaiohttpserverasyncdefhandler(request):returnweb.Response(body='Hello World')app=web.Application()app.router.add_get('/',handler)app.middlewares.append(aiohttpserver.enable_tracing)if__name__=='__main__':web.run_app(app)ClientClient call sites are instrumented implicitly by executing a set of
availableclient_hooksthat monkey-patch some API points in several
common libraries likeaiohttpandaiobotocore. The initialization of
those hooks is usually also done from the middleware class's__init__method.Usage is via theclient_hooksinterface.fromopentracing_async_instrumentationimportclient_hooksclient_hooks.install_all_patches()CustomizationFor theaiohttplibrary, in case you want to set custom tags
to spans depending on content or some metadata of responses,
you can setresponse_handler_hook.
The hook must be a method with a signature(response, span),
whereresponseandspanare positional arguments,
so you can use different names for them if needed.fromopentracing_async_instrumentation.client_hooks.aiohttpclientimportpatcherdefhook(response,span):ifnotresponse.ok:span.set_tag('error','true')patcher.set_response_handler_hook(hook)DevelopmentTo prepare a development environment please execute the following commands.virtualenvenvsourceenv/bin/activate
makebootstrap
maketestYou can usetoxto run tests as well.tox