Saravanan666/pypi-org huggingface dataset:
Package: continuum_ci
Continuum is a lightweight continuous integration tool: no web
interface, no scheduler. It runs on command line and is triggered by
cron.InstallationYou can install it using PIP, typingpip install continuum_ci. This
will install thecontinuumscript in you PATH. You may also download
the archive, expand it and type in the created directorypython
setup.py install.While calling continuum, you must pass the configuration file name on
the command line:continuum config.ymlConfigurationConfiguration is in YAML format:directory:  /tmp
email:
  smtp_host: smtp.foo.com
  smtp_user: username
  smtp_pass: password
  recipient: foo@bar.com
  sender:    foo@bar.com
  success:   false

modules:
  continuum:
    url:     https://github.com/c4s4/continuum.git
    command: |
      set -e
      virtualenv env --no-site-packages
      . env/bin/activate
      pip install -r etc/requirements.txt
      bee test
  module2:
    url:     https://github.com/foo/bar.git
    command: |
      set -e
      commands to run the testThe first part indicates:directory: the directory where modules will be checked out. Currently
only GIT projects are supported.email: put~if you don’t want any email.If you wait to receive email reports, provide following fields:smtp_host: the hostname of your SMTP server.smtp_user: the username to access SMTP server.smtp_pass: the password to access SMTP server.recipient: the email of the recipient of the build report.sender: the email address if the sender of the report.success: tells if continuum should send an email on success. Iffalse, it will only send an email on build error.Ifsmtp_host,smtp_userandsmtp_passare not set, their value
is extracted fromMAIL_SMTP,MAIL_USERNAMEandMAIL_PASSWORDenvironment variables.The second one is the list of modules, with, for each module:url: the URL of the module that GIT will use to get the sources.command: the command to run tests, must return 0 on success and a
different value on error (as any Unix script should). Note the pipe
character (that is|) after thecommand:declaration.The most important thing to remember about editting YAML is that Tab
characters are forbidden (and should be replaced with spaces to properly
indent). Please see YAML specification (athttp://www.yaml.org/spec/1.2/spec.html) for more details.CrontabThis script is triggered using cron, with as configuration as follows
(in file/etc/crontab):# run continuum at 4 every night
0   4 * * *  me    continuum /home/me/etc/continuum.ymlPlease make sure that the PATH to continuum is defined in your cron
configuration. You may add the right PATH at the beginning of yourcrontabfile as following:PATH=/path/to/continuum:/rest/of/my/path

# run continuum at 4 every night
0   4 * * *  me    continuum /home/me/etc/continuum.ymlReleases0.2.0(2020-05-07): Using mail1 library.0.1.6(2020-05-05): Bug fixed.0.1.5(2020-05-05): Documentation fixed and added integration
test.0.1.4(2020-05-04): Migration to Python 3.0.1.3(2020-05-04): Project renamed continuum_ci and added
makefile.0.1.2(2014-04-15): Fixed documentation.0.1.1(2014-04-11): Improved email reporting.0.1.0(2014-04-08): First public release.Enjoy!
Package: continuum-mechanics
Continuum MechanicsUtilities for doing calculations in continuum mechanics.Free software:MIT license.Documentation:https://continuum-mechanics.readthedocs.io.FeaturesMake long vector calculus calculations simple.Support different coordinate systems.Visualize entities such as second rank tensors.CitationTo citecontinuum_mechanicsin publications useNicolás Guarín-Zapata. (2020). nicoguaro/continuum_mechanics: Version 0.2.1
(Version v0.2.1). Zenodo.http://doi.org/10.5281/zenodo.4029448A BibTeX entry for LaTeX users is@software{continuum_mechanics,title={continuum_mechanics: Continuum Mechanics calculations in Python},version={0.2.1},author={Guarín-Zapata, Nicolás},year=2020,keywords={Python, Finite elements, Scientific computing, Computational mechanics},abstract={`continuum_mechanics` is a Python package built on top of SymPy to aid
    with calculations in Continuum Mechanics that are commonly lengthy and
    tedious if done by hand. It also provides visualization capabilities for
    second-order tensors such as Mohr's circle to help in stress analyses.},url={https://github.com/nicoguaro/continuum_mechanics},doi={http://doi.org/10.5281/zenodo.4029448}}CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-04-21)First release on PyPI.0.1.2 (2019-04-04)Add elasticity operators.0.2.0 (2019-12-02)Python 2 support dropped.Fix vector gradient for curvilinear coordinates.Add divergence for second-order tensors.0.2.2 (2021-04-12)Python 3.6 support dropped.
Package: contiv-sdk
# contiv-sdk[![Build Status](https://img.shields.io/travis/sw4iot/contiv-sdk.svg)](https://travis-ci.org/sw4iot/contiv-sdk)
[![PyPI](https://img.shields.io/pypi/v/contiv-sdk.svg)](https://pypi.org/project/contiv-sdk/)
[![Updates](https://pyup.io/repos/github/sw4iot/contiv-sdk/shield.svg)](https://pyup.io/repos/github/sw4iot/contiv-sdk/)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/contiv-sdk.svg)
[![Hex.pm](https://img.shields.io/hexpm/l/plug.svg)](https://www.apache.org/licenses/LICENSE-2.0)
Package: contourheightmap
Contour HeightmapA fast python library and command line tool for generating contour maps from heightmaps and images.Given an image file (preferably RGB PNG), it will output a PNG with topographic contour lines
and an SVG file of the contour lines.If viewing this document on the gitlab page, you should see some example images below:Questions? Contributions? Bug reports? Open an issue on thegitlab page for the project.
We are very interested in hearing your use cases forcontourheightmapto help drive the roadmap.RoadmapMore control on the output imageMore control on the output svgContributorsLuke MillerInstallingpip install contourheightmaporpy -m pip install contourheightmapSourcegit clone https://gitlab.com/dodgyville/contourheightmapQuick StartHow do I...Contour an image from the shell command line?contourheightmap path/to/heightmap.pngResult will be in output.png and output.svgProvide an output file from the shell command line?contourheightmap path/to/heightmap.png my-output.pngResult will be in my-output.png and my-output.svgContour an image from within python?fromcontourheightmapimportContourHeightmapc=ContourHeightmap()c.contour("path/to/heightmap.png")Result will be in output.png and output.svgProvide an output filename within python?fromcontourheightmapimportContourHeightmapc=ContourHeightmap()c.contour("path/to/heightmap.png","path/to/output.png")Output will also be in path/to/output.svgChangelog1.1.0begin switch from setup.py topyprojectandpoetryadded cli tool to make library available from command line
Package: contourpy
ContourPy is a Python library for calculating contours of 2D quadrilateral grids.  It is written in C++11 and wrapped using pybind11.It contains the 2005 and 2014 algorithms used in Matplotlib as well as a newer algorithm that includes more features and is available in both serial and multithreaded versions.  It provides an easy way for Python libraries to use contouring algorithms without having to include Matplotlib as a dependency.Documentation:https://contourpy.readthedocs.ioSource code:https://github.com/contourpy/contourpyLatest releaseDownloadsPython versionCoverage
Package: contours
contours - contour calculation with matplotlibThecontourspackage exposes Matplotlib’s contour generators to the user
providing an equivalent of MATLAB’scontourcfunction.  This is done for
grids (including curvilinear) as well as unstructured data via Delaunay
triangulation (FUTURE).Regular contours can be returned asNumPyarrays or asShapelyLineStrings and LinearRings.  Filled contours can be returned asNumPyarrays or asShapelyPolygons.Contour calculation without plotting is currently an open issue#367for
Matplotlib.  In that discussion, the type of hackery done in this library is
discouraged by the Matplotlib developers.  As of this writing there has been no
decision as to whether exposing contour calculations is a feature that should
be included in Matplotlib or not.  If such a refactoring in Matplotlib ever
takes place, this library will be refactored to avoid using Matplotlib’s
internal components.LinksDownloadGitHubDocumentationFeaturesFilled and non-filled contours.Contours on regular grids.TODOContours on unstructured data.ExamplesA contrived example usingQuadContourGeneratorto compute the area and
circumference of a circle and a ring.>>> from contours.core import shapely_formatter as shapely_fmt
>>> from contours.quad import QuadContourGenerator
>>> import numpy as np
>>> x = np.arange(-1, 1+0.01, 0.01)
>>> y = np.arange(-1, 1+0.01, 0.01)
>>> z = np.sqrt(x[:, np.newaxis]**2 + y[np.newaxis, :]**2)
>>> c = QuadContourGenerator.from_rectilinear(x, y, z, shapely_fmt)
>>> contour = c.filled_contour(max=1.0)
>>> print('Area: {:0.2f}'.format(contour[0].area))
Area: 3.14
>>> print('Length: {:0.2f}'.format(contour[0].length))
Length: 6.28
>>> contour = c.filled_contour(min=0.5, max=1.0)
>>> print('Area: {:0.2f}'.format(contour[0].area))
Area: 2.36
>>> print('Length: {:0.2f}'.format(contour[0].exterior.length))
Length: 6.28
>>> print('Length: {:0.2f}'.format(contour[0].interiors[0].length))
Length: 3.14AuthorThecontoursmodule was written by Michael R. Shannon (@mrshannon) <mrshannon.aerospace@gmail.com> in 2017.It is maintained by:Michael R. Shannon (@mrshannon)
<mrshannon.aerospace@gmail.com> 2017-TestingTODO
Package: contourviz
ContourViz--------This package uses music21 to process musical notation and creates a web-based visualrepresentation of the melodic contour within the browser. It creates a stand-alonewebsite within the current working directory called 'results'. It then serves thisfolder locally within the web browser, offering contour maps of either a single melodyor all of the notation files within the passed folder path.To install:>>> pip install contourvizTo use on the command line:>>> # Navigate to an empty directory (or at least one without a folder called 'results')>>> # Create a chart of multiple melodic contours>>> chart-contours '/path/to/directory/full/of/xml/or/mxl/files'>>>>>> # Create a chart of a single melodic contour>>> chart-single-contour '/path/to/file.xml'For use within the Python interpreter:>>> # Navigate to an empty directory (or at least one without a folder called 'results')>>> testFile = '/path/to/file.xml'>>> testPath = '/path/to/directory/full/of/xml/or/mxl/files'>>>>>> # Create a single contour line from a given file>>> createDataFromFile(testFile)>>>>>> # Create a set of contour lines from all files in a given directory>>> createDataFromDirectory(testPath)In progress updates and known issues include the following:* It currently only works with single line (monophonic) melodies.* The frequency labels draw from a logarithmic reading of each note's frequency, not note names.* When using the interpreter: after serving the file, the Python script does not return to the correct working directory. This may require exiting and reentering the interpreter or navigating the command line to repeat the process.
Package: contpl
Examples:$ contpl --tpl infile.tpl --out file.out --delim '$$$' --test 30Reads the infile.tpl template and rewrites its contents to infile.out,substituting "$$$test"$ contpl --tpl infile.tpl --out outdir --delim '%' --var1 20 --var2 helloReads the infile.tpl template and rewrites its contents to outdir/infile.tpl,substituting "%var1" and "%var2"$ contpl --tpl indir --out outdir --var1 10 --var2 50Reads all the files from indir and rewrites them to outdir,substituting "$$$var1" and "$$$var2" ("$$$" is the default delimiter)$ contpl --tpl indir/\*.tpl --out outdir --var1 10 --var 20Reads all the files matching the mask (glob) "*.tpl" and rewrites them tooutdir, substituting "$$$var1" and "$$$var2"
Package: contractpy
contractpycontractpy is a tiny library for validating the data against a contract.Basic usageYou could simply create a contract object and validate your data if it conforms to the contract.from pycontract import Contract, Types

my_contract = {
    'name': Types.STRING,
    'id': Types.INTEGER
}
contract = Contract(my_contract)

assert contract.verify({'name': 'Captain America': 'id': 12345}) is TrueYes, it is as simple as this.Also, it works for the complicated data like nested dict object (Values in a dict object can be another dict object or list of dict objects). In such cases, it will recursively iterate over the inner dicts and validate them against the contract. Please check out the below example,my_contract = {
    'name': Types.STRING,
    'id': Types.INTEGER,
    'orders': [
        {
            'orderId': Types:INTEGER,
            'price': Types:FLOAT,
        }
    ],
    comments: [Types.String]
}

data = {
    'name': 'Hazel Grace',
    'id: 57331,
    'orders': [
        {
            'orderId': 1,
            'price': 420.45
        },
        {
            'orderId': 2,
            'price': 750.38
        }
    ],
    comments: ["I really liked the product!", "I am completely satisfied."]
}

assert Contract(my_contract).verify(data) is TrueIf you want to specify a list for any field, use the square bracets ( [ ] ) as specified in the fielddata. In such cases, it will validate all the values against the contract that are present in the list.You could also do the contract testing for the REST APIs using this library. This API contract testing would be more useful in the microservices architecture.
For Example,def test_users_api_conforms_the_contract():
    user_api_contract = {
        'page': Types.INTEGER,
        'per_page': Types.INTEGER,
        'total': Types.INTEGER,
        'total_pages': Types.INTEGER,
        'data': [
            {
                'id': Types.INTEGER,
                'name': Types.STRING,
                'year': Types.INTEGER,
                'color': Types.STRING,
                'pantone_value': Types.STRING
            }
        ],
        'ad': {
            'company': Types.STRING,
            'url': Types.STRING,
            'text': Types.STRING
        }
    }

    response = requests.get('https://reqres.in/api/user?page=1')

    assert response.status_code == 200
    assert Contract(user_api_contract).verify(response.json()) is TrueNote: Here, the test api is powered byreqres.in
Package: contracts-lib-py
contracts-lib-pyWraps Nevermined contracts and web3 functions.nevermined.ioAttributionThis project is based in theOcean Protocol Keeper-py-lib. It keeps the same Apache v2 License and adds some improvements.LicenseCopyright 2020 Keyko GmbH.

Licensed 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 at

   http://www.apache.org/licenses/LICENSE-2.0

Unless 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: contractual
ContractualInstallationpip install contractualUsehow to use-Contract FilesContract files comply with the Pact file format seen athttps://github.com/pact-foundation/pact-specification/tree/version-2There is a key difference though-Contractual supports mocking out arbitrary interfaces, while Pact limits itself
to http requests. As such, a Contractual file can only be used with a Pact verifier
if you limit the unchecked mocks toHttpContractMock. In the files themselves,
you will see a list of interactions having the form{"description":"get all users for max","request":{},"response":{},"providerState":"a user with an id named 'u:ser' exists"}That is a valid HTTP contract. A more generalContractMockcontract would have the
form{"description":"get all users for max","contractMock":{"contractName":"Name","args":[]},"response":{},"providerState":"a user with an id named 'user' exists"}DevelopmentDevelopment EnvironmentPoetry is used to manage the project and dependencies. Once you have poetry installedpip install --user poetry, you can runpoetry installto setup a virtaulenv for
your project. Dependencies can be updated usingpoetry addorpoetry removeand
committing the updated pyproject.toml and poetry.lock files.ReleaseCI is handled on Gitlab athttps://gitlab.com/pjbecotte/contractual. There is a make
target to create a new release by tagging a new version and then incrementing to the
next beta version. (This requires permissions to push to master)
Package: contradict
Contra[dict]DescriptionContradict provides a thread-safe implementation of the SortedDict. A SortedDict is a dict which can be traversed in ascending or descending order. This is different from the OrderedDict which can be traversed in the order in which the elements were added. The collection type exposes APIs to perform the following operationsget,set,contains,items,keysandvalues.Object UsageFor adding an object to the SortedDict, the object needs to implement it's comparator logic and a hash function.class GitRepo:
    def __init__(self, url, stars, forks):
        self.url = url
        self.stars = stars
        self.forks = forks

    # The object needs to implement the following methods
    def __eq__(self, other):
        return self.name == other.name and self.stars == other.stars and self.forks == other.forks

    def __ne__(self, other):
        return self.name != other.name or self.stars != other.stars or self.forks != other.forks

    def __lt__(self, other):
        # The two repos are first compared based on stars then forks and then sorted lexically based on url
        if self.stars == other.stars and self.forks == other.forks return self.url < other.url

    def __le__(self, other):
        if self.stars == other.stars and self.forks == other.forks return self.url <= other.url

    def __gt__(self, other):
        if self.stars == other.stars and self.forks == other.forks return self.url > other.url

    def __ge__(self, other):
        if self.stars == other.stars and self.forks == other.forks return self.url >= other.url
    # Use any unique attribute to hash
    def __hash__(self):
        return hash(self.url)DependenciesPython 3Installationpip install --upgrade contradictUsagefrom contradict.sorted_dict import SortedDict


sorted_dict = SortedDict()           # Creates an empty SortedDict
sorted_dict.set(key, value)          # Sets a key, value pair
sorted_dict.get(key)                 # Returns the value, if key is present or None
sorted_dict.items()                  # Returns an interator to the key, value pairs in asc order
sorted_dict.keys()                   # Returns an interator to the keys in asc order
sorted_dict.values()                 # Returns an interator to the values in asc order of keys
sorted_dict.items(reverse=True)      # Returns an interator to the key, value pairs in desc order
sorted_dict.keys(reverse=True)       # Returns an interator to the keys in desc order
sorted_dict.values(reverse=True)     # Returns an interator to the values in desc order of keysLicenseMITChangelog2.0.1Fixed the README2.0.0Added thread safety and fixed a bug with reverse sorting1.0.2Updated README
Package: contrail
ContrailPublic Cloud Market Price TrackerUC Davis ECS 193, 2019Contrail is a public cloud market price tracker that allows you to easily access and compare the prices and
characteristics of VMs over various locations, cloud providers, and times.Quick StartVirtual EnvironmentCreate virtual environment:virtualenv -p python3 venv
OR
python3 -m virtualenv venvStart virtual environment:source venv/bin/activateYou should see(venv)show up in command prompt.Install requirements our project uses:pip install -r requirements.txtTo exit virtual environment:deactivateConfigureBy default, the site will read data from the official Contrail database. To collect your own data, seeCollecting
your own databelow.Start DjangoMake sure you are in the main Contrail folder and the virtual environment is activated.Collect static files:python contrail.py frontend collectstaticStart the Django server:python contrail.py frontend runserverOpen127.0.0.1:8000in a browser.API/api/getinstances/Given attributes, return instances that match and their pricesrequest:{
    'operating_system': "Linux",
    'aws': "True",
    'gcp': "True",
    'azure': "False",
    'region': None,
    'vcpus': None,
    'memory': 8,
}response:{
    "instance_type": "c4"
    "operating_system": "Linux",
    "provider": "AWS",
    "region": "US East",
    "vcpus": 8,
    "memory": 8,
    "reserved", "spot",
    "price_type": "on_demand",
    "price": 0.233,
    "price_unit": "per hour"
}Collecting your own dataContrail is split into a few distinct components:Crawler: Collects and stores raw offer data from various cloud providers.Loader: Parses raw offer data and stores it in a Clickhouse data warehouse.API/Frontend: Communicates with the data warehouse and displays data nicely.The Quick Start above only sets up the API/Frontend component. By default, it points to our own data source. You will
have to set up your own backend (crawler and loader) to collect your own data.Read more about setting up the first two components here:Crawler,Loader.
Package: contrail-api-cli
[![Build Status](https://travis-ci.org/eonpatapon/contrail-api-cli.svg?branch=master)](https://travis-ci.org/eonpatapon/contrail-api-cli)
[![Doc Status](https://readthedocs.org/projects/contrail-api-cli/badge/?version=latest)](http://contrail-api-cli.readthedocs.org/en/latest/)
[![Coverage Status](https://coveralls.io/repos/github/eonpatapon/contrail-api-cli/badge.svg?branch=master)](https://coveralls.io/github/eonpatapon/contrail-api-cli?branch=master)
[![Join the chat athttps://gitter.im/eonpatapon/contrail-api-cli](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/eonpatapon/contrail-api-cli?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)contrail-api-cliSimple CLI program to browse Contrail API server## Installation### Python virtualenvYou can install contrail-api-cli inside a python virtualenv.
First create the virtualenv and install contrail-api-cli with pip.$ virtualenv contrail-api-cli-venv
$ source contrail-api-cli-venv/bin/activate
(contrail-api-cli-venv) $ pip install contrail-api-cli### Debian packageFirst you need to satisfy dependencies missing in Ubuntu Trusty. You can
install them from newer distribution or from backports (eg.
[tcpcloud/extra](https://launchpad.net/~tcpcloud/+archive/ubuntu/extra))python-pathlibpython-prompt-toolkitpython-wcwidthWhen dependencies are satisfied, you can build package:dpkg-buildpackage -uc -usThen upload into your repository or install directly:dpkg -i ../contrail-api-cli_*.deb## UsageRuncontrail-api-clishellto start the cli. Use the-hoption to see all supported options. By default it will try to connect tolocalhoston port8082with no authentication.Typehelpto get the list of all available commands.Here is a screen cast to see contrail-api-cli in action:[![asciicast](https://asciinema.org/a/8jx1e0ge56auloah7m6hmpcuz.png)](https://asciinema.org/a/8jx1e0ge56auloah7m6hmpcuz)## Authenticationcontrail-api-clisupports keystone (v2, v3) and Basic HTTP authentication mechanisms.When running the contrail API server with--authkeystoneyou can login on port 8082 with keystone auth and on port 8095 with basic http auth.### Basic HTTP authcontrail-api-cli –host localhost:8095 –os-auth-plugin http –os-username admin –os-password contrail123 shellThe username and password can be sourced from the environment variablesOS_USERNAME,OS_PASSWORD.The auth plugin default tohttpunlessOS_AUTH_PLUGINis set.### Kerberos authThe easiest way is to source your openstack openrc file and runcontrail-api-cli –os-auth-plugin [v2password|v3password] shellSeecontrail-api-cli--os-auth-plugin[v2password|v3password]--helpfor all options.## What if### virtualenv is missingInstall virtualenv# pip install virtualenv### pip is missingInstall pip# easy_install pip