semvec/pypi-packages huggingface dataset:
revops 0.0.6
RevOps Python Client

# A python module for integrating RevOps

[RevOps](https://www.revops.io)

## Installation

Install from PyPi using pip, a package manager for Python.

```
pip install revops
```

Don't have pip installed? Try installing it, by running this from the command
line:

    $ curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python

Or, you can [download the source code
(ZIP)](https://github.com/revops-io/revops-python/zipball/master "revops-python
source code") for `revops-python`, and then run:

    python setup.py install

## Getting Started

Create a `RevOpsAPI` client.

```python
  from revops.api import RevOpsAPI
  api = RevOpsAPI()
```

### Authentication

Get your API token from your RevOps instance. Set the token to REVOPS_API_KEY in your environment variables.

    export REVOPS_API_KEY="xxxxxxxxxxxxxxxxxxxxxxx"

```python
  from revops.api import RevOpsAPI
  api = RevOpsAPI()
```

### Send your first UsageEvent
```python
from revops.api import RevOpsAPI

# Make sure you've set your REVOPS_API_KEY env var.
# $> export REVOPS_API_KEY="xxxx"
api = RevOpsAPI()

# Create a UsageEvent Request
product_usage = api.usage.events.create(
    transaction_id = "my-first-usage-event-1",
    mode = "insert",
)

# Add an hourly outbound-voice-minutes with the value 100
# To the UsageEvent request
product_usage.add_metric(
    account_id = "my-first-account-id-1",
    product = "voice-minutes",
    metric_name = "outbound-voice-minutes",
    metric_value = 100,
    metric_resolution = "hour",
)

product_usage.commit()
```
django-redux 1.0.0
A re-usable bridge between Django channels and Redux Edit

Django Redux
=============================

A re-usable bridge between Django channels and Redux.

Quickstart
----------

::

    $ pip install django_redux
    $ npm install django-channels django_redux

Create a file called `engine.py` for your project::

    from django_redux import action, AsyncReduxConsumer


    class MyConsumer(AsyncReduxConsumer):

        async def connect(self, message):
            if message.user.is_authenticated:
                await self.send_json({
                    'type': 'SET_USER',
                    'user': {
                        'username': self.message.user.username,
                    }
                })

        # This method will be called when the `INCREMENT_COUNTER` action gets
        # fired from the JS via the reduxBridge (see below).
        @action('INCREMENT_COUNTER')
        async def incr_counter(self, message):
            await self.send_json({'type': 'INCREMENTED_COUNTER', 'incrementBy': message['incrementBy']})


In your js entry point::

    // app.js

    import React from 'react';

    import { render } from 'react-dom';
    import { Provider } from 'react-redux';
    import { createStore, } from 'redux';

    import reducer from '../reducers';
    import Root from '../containers/Root.react';

    import { WebSocketBridge } from 'django-channels';
    import { eventToAction } from 'django_redux';

    const store = createStore(
      reducer,
    );


    export const reduxBridge = new WebSocketBridge();
    reduxBridge.connect("ws://localhost:8000/ws/");
    reduxBridge.addEventListener("message", eventToAction(store));

    render(
      <Provider store={store}>
        <Root />
      </Provider>,
      document.getElementById('root')
    );

To send an action from redux::

    import { createAction } from 'redux-actions';

    import ActionTypes from './constants';
    import { reduxBridge } from './app';


    export const incrementCounter = createAction(ActionTypes.INCREMENT_COUNTER, (incrementBy) => {
      reduxBridge.send({
        type: ActionTypes.INCREMENT_COUNTER,
        incrementBy
      });
    });

To send an action from the backend::

    from django_redux import send_action

    await send_action('mygroup', {
        'type': 'ACTION_NAME',
        'payload': {'any': 'thing'},
    })

Groups
------

All clients are automatically added to a group called `"broadcast"`.

Authenticated users are automatically added to a group called `"user.{user.pk}"` so you they can be conveniently addressed.

TODO:

* Tests
    * ``send_action``
* Data binding
* Docs
    * Multiplexing

Credits
-------

Most of this code is adapted from `johnpaulett/channel_chat <https://github.com/johnpaulett/channel_chat>`_.
webcubers 1.8.1
webcubers python interface

# WebCubers Package & CLI Tool

this is interface package for WebCubers portal.

# Usage
```bash
 __    __     _       ___      _
/ / /\ \ \___| |__   / __\   _| |__   ___ _ __ ___
\ \/  \/ / _ \ '_ \ / / | | | | '_ \ / _ \ '__/ __|
 \  /\  /  __/ |_) / /__| |_| | |_) |  __/ |  \__ \
  \/  \/ \___|_.__/\____/\__,_|_.__/ \___|_|  |___/
             < WebCubers-CLI v1.8.1 >

usage: cubers [-h] {login,snippets,logout,profile} ...

WebCubers CLI Connector.

positional arguments:
  {login,snippets,logout,profile}

optional arguments:
  -h, --help            show this help message and exit
```

## Login
```bash
Cubers login MyUsername MyApiKey
```
## Profile
```bash
Cubers profile
```
## Leaders
```bash
Cubers snippets
```
## OTP
```bash
Cubers otp
```
## Connection
```bash
Cubers connection
```
## Snippets
```bash
Cubers snippets
```
## Repository
```bash
Cubers repo
Cubers repo --download serverfile.py
Cubers repo --upload localfile.py --force
```
## Logout
```bash
Cubers logout
```
anticipython 1.0.3
Create .ics calendars for upcoming CPython releases ����
Requires Python: >=3.6

# Anticipython

[![Build Status](https://dev.azure.com/briancristante/Anticipython/_apis/build/status/Anticipython?branchName=master)](https://dev.azure.com/briancristante/Anticipython/_build/latest?definitionId=10&branchName=master)

Create .ics calendars for upcoming CPython releases ����

## Usage

Requires Python 3.6 or later.

```bash
pip install anticipython
python -m anticipython
# Produces an output file named `cpython_releases.ics`
```

### Power user configuration
Edit `peps.py` to include the version and PEPs you want to use.
coriolis 0.0.1
Quick visualization python software for NetCDF files

# Coriolis

## What is it ?
`coriolis` is a quick visualization python software developped using PyQt5 and xarray. 
It allows the user to get a quick insight of a NetCDF (.nc) file.

It provides multi-dimensional field main statistics, an embedded matplotlib canvas 
to visualize the data (1-D and 2-D plots) and some features to save
the figure, scale the data, change the colorbar, use non-linear axis scales and others

An animation widget is also implemented. However, at this point, matplotlib is not fast enough to enable a 
confortable and quick visualization refreshment. Other software such as NcView should be used instead.

More importantly, `coriolis` allows the user to precisely select the data to plot, namely the needed slices
can be easily given.


![Example](./example.png "Example")

## How to install it ?

You need to install the dependencies before installing the package. They were
not included within the package due to some issues with pip-installed PyQt5
package.
We recommend therefore the Anaconda distribution for installing those dependencies.

In a pre-activated python3 environment, you can simply do :

``` 
$ conda install matplotlib xarray netcdf4 cartopy`
$ pip install coriolis
```


## How to use it ?

As for now, only NetCDF (.nc) files can be processed.

You can use the software by running the command :

`$ coriolis yourfile.nc`

## How to customize it ?

If you want to customize the figures style, 
you can modify the custom.mplstyle file which is in the package.