Saravanan666/pypi-org huggingface dataset:
Package: open-cli3
Open-CLI3A CLI for every service which exposes a OpenAPI (Swagger) specification endpoint.From the OpenAPI Specification project:The goal of The OpenAPI Specification is to define a standard, language-agnostic interface to REST APIs which allows both humans and computers to discover and understand the capabilities of the service without access to source code, documentation, or through network traffic inspection.DemoDockerTo start a CLI session run:docker run -it privcloudcom/open-cli3 -s <swagger-spec-url>e.g:docker run -it privcloudcom/open-cli3 -s http://petstore.swagger.io/v3/swagger.jsonCLI sessionTo start a CLI session run:open-cli3 -s <swagger-spec-url>e.g:open-cli3 -s https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore-expanded.jsonRunning CLI session will automatically create config file at path~/.open-cli3-config/config.cfgTo use profile config pass profile flag with desired profile name:open-cli3 --profile <profile_name>e.g.:open-cli3 --profile profile1This will work only if you specify profile in your open-cli3 config file: path~/.open-cli3-config/config.cfg.
Example of config file:[profile1]
endpoint = <endpoint>
access_token = <access_token>To get data without running CLI session, please specify-cflag. It will automatically execute specified command
and return result data. Example:open-cli3 -s <swagger-spec-url> -c 'auth:login --body.email=<user_email> --body.password=<user_password>'oropen-cli3 --profile profile1 -c 'auth:login --body.email=<user_email> --body.password=<user_password>').If a profile name (--profileflag) and swagger url (-sflag) are provided (example:open-cli3 -s <swagger-spec-url> --profile profile1), the profile will take precedence. If such profile does not exist CLI will automatically create config file for the
profile.If you want to measure the request and response total time you should use--print-request-timeflag. Example:open-cli3 -s <swagger-spec-url> --print-request-time trueFor help run:open-cli3 -hCreditsThis project relies on OpenApi3openapi3project & on Jonathan Slenderspython-prompt-toolkit.
Package: openclient
Devcontainers Contrib CLIInstallationpip install devcontainer-contrib[generate]Feature Generation:Usage: python -m devcontainer_contrib features generate [OPTIONS]
                                                        FEATURE_DEFINITION
                                                        OUTPUT_DIR

Arguments:
  FEATURE_DEFINITION  [required]
  OUTPUT_DIR          [required]

Options:
  --help                          Show this message and exit.Input for feature generation is afeature-definition.jsonfile
This is anextendedversion of thedevcontainer-feature.jsonfile withadditional fields:{...regular devcontainer-json fields  like id,name,description etc...# dependencies are list of features and options  (those will be installed as prerequisites to your feature)"dependencies":[{"feature":"ghcr.io/devcontainers-contrib/features/asdf-package:latest","options":{"plugin":"act","version":"latest"}}],# This command will be executed after the dependency feature list has been installed"install_command":"echo'Done'",# this example test scenario checks the default options (empty options dict), each test_command should exit wth code `0` if your feature is installed correctly."test_scenarios":[{"name":"test_defaults","image":"mcr.microsoft.com/devcontainers/base:debian","test_commands":["act--version"],"options":{}}]}redirect input{..."options":{"version":{"type":"string","default":"latest","description":"Selecttheversionofacttoinstall."}},# you can also redirect one of your actual devcontainer-feature.json options values into a dependency input, note the `$options.version` pointer to the asdf-package version option"dependencies":[{"feature":"ghcr.io/devcontainers-contrib/features/asdf-package:latest","options":{"plugin":"act","version":"$options.version"}}],...}Usage examplethis will generate the Elixir feature
It assumes you have the devcontainer-contrib cli already installedgitclonehttps://github.com/devcontainers-contrib/cli--depth1cdcli


devcontainer-contribfeaturesgenerate"./test/resources/test_feature_definitions/elixir-asdf/feature-definition.json""./output_dir"
Package: openclimate
OpenClimate-pyclientOpenClimate Python Client is a Python 3.8+ package for theOpenClimate API. The goal of this package is to make emissions data and pledges more accessible.Installationpip install openclimateUsageImport and create aClient()objectfromopenclimateimportClientclient=Client()Retrieving dataEmissionsRetrieve all emissions data for a single actor. Here I am retrieving emissions data for Canadadf=client.emissions(actor_id='CA')Retrieve all emissions data for a list of actors. Here I am retrieving emission data for the United States, Canada, and Great Britain.df=client.emissions(actor_id=['US','CA','GB'])Return the different datasets available for a particular actor:df=client.emissions_datasets(actor_id='US')Only select data for a particular datasetdf=client.emissions_datasets(actor_id='US',datasource_id='GCB2022:national_fossil_emissions:v1.0')TargetsRetrieve emissions targets for a particule actordf=client.targets(actor_id='US')PopulationRetrieve population data.df=client.population(actor_id=['US','CA','GB'])GDPRetrieve GDP data.df=client.gdp(actor_id=['US','CA','GB'])Searching for codesuse the following to list the actor_ids for countries:df=client.country_codes()search for actor codes:df=client.search(query='Minnesota')get all the parts of an actor. Here I am returning the actor_id for each US state.df=client.parts(actor_id='US',part_type='adm1')
Package: open-close-mixin
open-close-mixinAboutEasy pluggable Mixin (and decorators) for objects that may benefit from open-close dynamics.InstallingYou can simply install it usingpipas follows:$pipinstallopen-close-mixinUsageYou may import anOpenCloseMixinalong some other decorators from the package root and use them further on to create your own class with open and close dynamics!>>>fromopen_close_mixinimportOpenCloseMixin,always>>>classFoo(OpenCloseMixin):>>># only while open, that's default behaviour>>>defrun_when_open(self):>>>print("The instance is open so I was able to run")>>>>>>@always>>>defrun_always(self):>>>print("I am ALWAYS able to run, whether the instance is open or not")>>>>>>f=Foo()>>>f.open()>>>f.run_always()IamALWAYSabletorun,whethertheinstanceisopenornot>>>>>>f.run_when_open()TheinstanceisopensoIwasabletorun>>>>>>f.close()>>>f.run_always()IamALWAYSabletorun,whethertheinstanceisopenornot>>>>>>f.run_when_open()Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/home/alberto/Projects/personal/open-close-mixin/open_close_mixin/decorators.py",line27,inwrapperraiseexceptionfromNoneValueError:Theinstanceisnotopenandthemethod"Foo.run_when_open"cannotrunundersuchcondition.
Package: opencmiss2cmlibs
This tool is meant to help update code from using OpenCMISS python packages to CMLibs python packages.
It also contains a tool to upgrade Argon documents from OpenCMISS to CMLibs.Install with:pip install opencmiss2cmlibsUsage:opencmiss2cmlibs <directory-of-python-packge-to-update>This displays a diff of the changes onstdout.
To make the changes in-place and not create a backup file use:opencmiss2cmlibs -w -n <directory-of-python-packge-to-update>This form of the command is best suited for use with code that is under version control, Git or the like.To upgrade Argon documents us the following command:upgradeargondocuments <directory-containing-argon-files>This command will search through the directory tree looking for old Argon documents and convert them to new ones.Copyright 2023 University of AucklandLicensed 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: opencmiss.zinc
Zinc provides Python bindings to the visualisation library.
There are some examples available athttp://opencmiss.org/documentation/tutorials/index.html.
A typical usage often starts with creating a Context like this:from opencmiss.zinc import context
c = context.Context.create("my-context")There are some very cool things you can visualize with this library, like DICOM images, Hermite meshes and so on.First StepsThe examples are the best place for getting started with Zinc Python bindings.ContributorsAlan Wu
Hugh Sorby
Richard Christie
Package: opencnam
# python-opencnamA simple python library for getting caller ID name information.![OpenCNAM](https://www.opencnam.com/static/images/opencnam-logo-color-v2.png)This library uses [OpenCNAM](https://www.opencnam.com“opencnam”) as a backend.[![Build Status](https://secure.travis-ci.org/telephonyresearch/python-opencnam.png?branch=master)](http://travis-ci.org/telephonyresearch/python-opencnam)## InstallationInstall from PyPi using [pip](http://www.pip-installer.org/en/latest/), a
package manager for Python.$ pip install opencnamDon’t have pip installed? Try installing it, by running this from the command
line:$ curlhttps://raw.github.com/pypa/pip/master/contrib/get-pip.py| pythonOr you can [download the source code](https://github.com/telephonyresearch/python-opencnam/zipball/master“OpenCNAM
source code”) forOpenCNAM, and then run:$ python setup.py installYou may need to run the above commands withsudo.## UsageUsingpython-opencnamis easy:from opencnam import Phone

phone = Phone('+16284003994')
print phone.number, phone.cnamThe main object,Phone, defined in theopencnammodule accepts a phone
number as input, and (behind the scenes) queries the
[opencnam](http://www.opencnam.com“opencnam”) API to set thePhone.cnamattribute.## API AuthenticationTo specify your API credentials, just pass them into thePhoneconstructor,
like so:from opencnam import Phonephone = Phone(‘+16284003994’, account_sid=’ACxxx’, auth_token=’AUxxx’)## Changelogv06: 2018-11-30Use OpenCNAM v3.Support onlyaccount_sidandauth_tokenfor authentication,
removing the deprecatedapi_userandapi_key.Support Python 2.7 and Python 3.7v0.5: 2012-11-08Add support for OpenCNAM V2 API.Deprecate theapi_userandapi_keyauthentication parameters,
in favor ofaccount_sidandauth_token.v0.4: 2012-07-10Add 3 second timeout to CNAM lookups, so we won’t block for too long.v0.3: 2012-07-09Rewrite the backend to userequestsinstead ofslumber.Clean up documentation.Add public tests via Travis CI.v0.2: 2012-03-19Support API authentication.v0.1: 2012-02-26Initial release!
Package: open-coder
ChatGPT CLI ClientInstallationManual Installationgit clone https://github.com/hansololz/rubberduck-ai.git
cd rubberduck-ai
python setup.py installInstallation (pip)pip install rubberduck-aiAuthenticationAuthentication TokenThe CLI tool requires Open AI authentication token. Token can be obtained
by going tohttps://platform.openai.com/account/api-keys.Authentication MethodsChoose one of these options to authenticate the CLI tool:Set the environment variable:OPENAI_API_KEY=<AUTHENTICATION_TOKEN>.Use a command argument:rda --openai-api-key=<AUTHENTICATION_TOKEN>.Enter the API key when prompted while running the CLI tool.UsageEvaluation LoopRun the application:rdaSupported Commands.n .new: Create new session.p .print: Print current session.s .sessions: Change chat sessioncd clear ls: Session supported bash commandscd cls dir: Session supported cmd commandsSingle PromptProcess a single prompt with:rda <SINGLE_PROMPT> --openai-api-key=<AUTHENTICATION_TOKEN>
Package: opencollect
opencollectopencollect is an open-soured data collection engine.Requirementspython 3Installationpip3installopencollectUsagefromopencollectimportOpenCollectsession=OpenCollect()session.start()# Now send your data to it : )Examplepython3openconnect/sources/client.pyTrouble Shootingsocket.error:[Errno48]Addressalreadyinusenonroot@dev-ubuntu:~/opencollect$sudolsof-i:60312COMMANDPIDUSERFDTYPEDEVICESIZE/OFFNODENAMEipython10731nonroot11uIPv418629800t0TCP*:60312(LISTEN)nonroot@dev-ubuntu:~/opencollect$sudokill-910731nonroot@dev-ubuntu:~/opencollect$sudolsof-i:60312[6]+Killedipythonnonroot@dev-ubuntu:~/opencollect$License TermsCopyright (c) 2018 James K BowlerPermission 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: open-colorimeter-utils
Utilities for IO Rodeo's Open ColorimeterInstallingInstall using pip$pipinstallopen-colorimeter-utilsInstalling from sourceThis package uses thepoetrydependency manager.
The installation instructions for poetry can be foundhereOnce poetry is installed the open-colorimeter-utils package can be installed using$poetryinstallAdditional documentation on using poetry can be foundhereUsing the Open Colorimeter calibration toolThe Open Colorimeter calibration tool "oc-cal" is a command line program which can fit
calibratin data and generate the calibration.json used by the Open Colorimeter.Usage: oc-cal [OPTIONS] [INPUT_FILES]...Generates an Open Colorimeter calibration .json file from the .toml inputfiles.toml file format-----------------name = "TestName"          # Name of the testled = 630                  # Led wavelengthunits = "ppm"              # Measurement unitsfit_type = "polynomial"    # Fit type, polynomial or linearfit_order = 2              # Order of the fitvalues = [                 # Array of measurements[c0, c1, .... , cn],   # Measurements in units[a1, a1, .... , an]    # Corresponding absorbances]Options:-o, --output-file FILENAME  output file--help                      Show this message and exit.The input calibration data is provided in the from of one of more .toml files
with the following formatname="Nitrite API"led=520units="ppm"fit_type="polynomial"fit_order=2values=[[0.00,0.40,0.80,1.20,1.60,2.00],# concentration[0.00,0.30,0.59,0.88,1.14,1.39],# absorbance]In order to generate the calibrations simple run$oc-calnitrite.tomlThe oc-cal program will generate the calibrations.json file used by the open
colorimeter. An alternative name can be given to this file using the -o of
--output options.An example of the calibrations.json file generated using the data from the .toml
file above is shown below{"Nitrite API":{"units":"ppm","led":"520","fit_type":"polynomial","fit_coef":[0.11543984594053638,1.2747960322708907,0.0],"range":{"min":0.0,"max":1.39}}}In addtion the oc-cal program will fit the data and plots the results as shown below.An example of calibrations.json file made using multiple .toml input files is shown below{"Ammonia API":{"units":"ppm","led":"630","fit_type":"polynomial","fit_coef":[1.0128521350438369,1.890930808804952,0.0],"range":{"min":0.0,"max":2.0}},"Nitrate API":{"units":"ppm","led":"520","fit_type":"polynomial","fit_coef":[0.32039213453320625,34.032597696304,0.0],"range":{"min":0.0,"max":1.47}},"Nitrite API":{"units":"ppm","led":"520","fit_type":"polynomial","fit_coef":[0.13111937060865314,1.2591439203550079,0.0],"range":{"min":0.0,"max":1.4}}}
Package: opencone
OpenconeA Pinecone alternative written on top of OpenSearch by simplifying features of OpenSearchRequirementsInstall OpenSearch Backendor You can use a cloud hosted OpenSearch BackendPython librariespip3 install opensearch-py
pip3 install openconeUsageCreate an OpenconeClientfromopenconeimportOpenconeClientimportrandomimportnumpyasnpimporttimefromopensearchpyimportOpenSearchhost='localhost'port=9200auth=('admin','admin')# For testing only. Don't store credentials in code.# Create an OpenSearch clientclient=OpenSearch(hosts=[{"host":host,"port":port}],http_auth=auth,use_ssl=True,verify_certs=False,ssl_assert_hostname=False,ssl_show_warn=False)oc=OpenconeClient(client=client)Create an Index# Create an indexdimensions=4096t=time.time()try:oc.create_index(index_name="test",dimensions=dimensions)exceptExceptionasex:if"resource_already_exists_exception"instr(ex):oc.delete_index(index_name="test")oc.create_index(index_name="test",dimensions=dimensions)else:raiseexprint("Index created in ",time.time()-t)Upsert Vectors# Upsert vectors# [(<id>, <embeddings>, <metadata>),...]titles=["pp","qq","rr","ss","tt"]tags=["p1","p2","p3","p4","p5"]vectors=[]# Recommend to upsert 100 or less at a timeforiinrange(100):vectors.append(("id:"+str(i),np.random.randint(5,size=dimensions).tolist(),{"name":titles[random.randint(0,4)],"tags":tags[random.randint(0,4):random.randint(0,4)],"no":random.randint(2000,3000)}))t=time.time()oc.upsert(index_name="test",vectors=vectors)print("Upsert time:",time.time()-t)Fetch Vector# Fetch vectorprint(oc.fetch(index_name="test",_id="id:1"))Delete vector# Delete vectorprint(oc.delete(index_name="test",_id="id:1"))Search# Searchfilters={"no":{"$gte":2200,"$lte":2800},"name":{"$eq":"pp"},"tags":{"$in":["p1","t3"]}}t=time.time()rs=oc.search(index_name="test",vector=(np.random.randint(5,size=dimensions)/1.1).tolist(),filters=filters,metadata=False,limit=10000)print("Search time:",time.time()-t)foreachinrs:print(each)Delete an Index# Delete indexoc.delete_index(index_name="test")
Package: opencontainers
Open Containers PythonA simple Python implementation of Open Containers specifications. The code
is intentionally structured to mirror the go implementations for usability.
This include:opencontainers/image-specmaps toopencontainers/imageopencontainers/go-digestmaps toopencontainers/digestopencontainers/distribution-specmaps toopencontainers/distribution, which also includes a Python version of theReggie clientto interact with an OCI registry.See the documentation atvsoch.github.io/oci-python.
Package: opencontest-cli
OpenContest CLIA very simpleOpenContestcommand line client written in Python andrequests.UsageInstall this client usingpip:pip install opencontest-cliRegister an account on an OpenContest server:occ user -s homeserver.com -N name -E email -U username -P passwordSave username, homeserver (the server you registered your account on), and password to disk:occ save -U username -H homeserver.com -P paswordGet information about an OpenContest server:occ about -s server.comGet information about a contest:occ info -s server.com -c contestView the number of solves of each problem:occ solves -s server.com -c contestView the submission history of all users in a contest:occ history -s server.com -c contestSubmit code:occ submit -s server.com -c contest -p problem -c code_fileCheck user status:occ status -s server.com -c contestQuery your contest submission history:occ submissions -s server.com -c contestGet code for a specific submission number:occ code -s server.com -c contest -n submission_number
Package: opencontest-client
OpenContest ClientA very simpleOpenContestcommand line client written in Python. The only dependency is therequestslibrary. Tested with Linux only. Please report bugs on ourissues page.UsageYou can get started withpip install opencontest-clientNow register an account on an OpenContest server withocc register -s homeserver.com -N name -E email -U username -P passwordYou can save your username, homeserver (the server you registered your account on), and password withocc save -U username -H homeserver.com -P paswordQuery information about an OpenContest server withocc about -s server.comYou can view the contests on the server withocc contests -s server.comCheck the contest info withocc info -s server.com -c contestSave a problem statement withocc problems -s server.com -c contest -p problemNow you can submit withocc submit -s server.com -c contest -p problem -c code_fileAnd check your status withocc status -s server.com -c contestYou can query your submission history for a contestocc submissions -s server.com -c contestAnd examine a particular submission withocc code -s server.com -c contest -n submission_numberView the number of solves of each problem withocc solves -s server.com -c contest
Package: opencontest-server
OpenContest ServerAnOpenContestserver written using Python's HTTPServer and SQLite, with no external dependencies other than the Python standard library,requests, andFirejail.InstallationDockerRun theDocker Hub image:docker run -d -p 9534:9534 --name opencontest-server -v $PWD/contests:/usr/src/app/contests laduecs/opencontest-server:latestNote:$PWD/contestsis where the contests folder in the container is mapped to on the host and by default creates a new folder calledcontestsin the current directory. It can be replaced with the full path to a different if desired.AURInstall theopencontest-server-gitfrom the AUR:paru -S opencontest-server-gitStart the server withsystemctl start opencontest-server.PipInstallopencontest-serverwithpip:pip install opencontest-serverRun the server withocs.UsageYou can place contests like thesample contestin acontestsdirectory.For debugging, you can run the server with the--verboseflag.For production usage, you should put this server behind a reverse proxy like NGINX or Caddy because Python's HTTPServer does not implement any security features. You will also need to a domain name and a TLS certificate which you can easily obtain usingLet's Encrypt.
Package: opencopilot
OpenCopilot, an AI-driven Copilot Agent is designed to offer an efficient and controllable framework for software companies. OpenCopilot seamlessly integrates with a company's software ecosystem and performs complex tasks with minimal guidance.Getting startedDo not forget to include your OpenAI keys in theenv.pyafter making your own copy fromservice/env.py.example1. On your local machinea. BackendInstall requirements:cd service && pip3 install -r requirements.txtRun the server:cd service && python3 -m uvicorn main:app --reloadb. FrontendRun web chatbot:cd chat-fenpm install --legacy-peer-depsnpm startc. DatabaseBuild meta database:cd service && python3 initialize_chromaDB.py2. On DockerBefore you begin, make sure you have Docker and Docker Compose installed on your machine.Open a terminal or command prompt window and navigate to the project directory.Run the following command to start the application:docker-compose upOnce the application is running, you can access it in your web browser athttp://localhost:3000/