semvec/pypi-packages huggingface dataset:
pytest-ordering2 0.7.0
pytest plugin to run your tests in a specific order

pytest-ordering2
================
This is a fork of [pytest-ordering](https://github.com/ftobia/pytest-ordering).
That project is not maintained anymore, and there are several helpful PRs
waiting for merge. Therefore I decided to create this fork that tries to
combine the original code with most of the provided PRs.   
My hope is that the original project will be moved to the pytest
organization as outlined in 
[this issue](https://github.com/ftobia/pytest-ordering/issues/32). When this
happens, this fork will be obsolete. 


pytest-ordering2 is a pytest plugin to run your tests in a specific order.

[![Build Status](https://travis-ci.org/mrbean-bremen/pytest-ordering2.svg?branch=master)](https://travis-ci.org/mrbean-bremen/pytest-ordering2)

Have you ever wanted to easily run one of your tests before any others run?
Or run some tests last? Or run this one test before that other test? Or
make sure that this group of tests runs after this other group of tests?

Now you can.

Install with:

    pip install pytest-ordering2

This defines some pytest markers that you can use in your code.

For example, this:

    import pytest

    @pytest.mark.run(order=2)
    def test_foo():
        assert True

    @pytest.mark.run(order=1)
    def test_bar():
        assert True

Yields this output:

    $ py.test test_foo.py -vv
    ============================= test session starts ==============================
    platform darwin -- Python 2.7.5 -- py-1.4.20 -- pytest-2.5.2 -- env/bin/python
    plugins: ordering
    collected 2 items

    test_foo.py:7: test_bar PASSED
    test_foo.py:3: test_foo PASSED

    =========================== 2 passed in 0.01 seconds ===========================

You can find more information in the [documentation](https://mrbean-bremen.github.io/pytest-ordering2/).
polis 0.0.1
placeholder.
Requires Python: >=3.6

# 🐋 equities 

## Overview: 

    equities allows for easy access to the SEC's XBRL Financial Statement Dataset
    Parsed data is stored locally and served to the user in pandas dataframes

###### The Dataset: 

https://www.sec.gov/dera/data/financial-statement-data-sets.html

## Install: 

    pip3 install equities

## Donate: 

Consider donating bitcoin to fund the future development of this project. 

    bitcoin wallet address: 3LU5MEaAXRJoCo6vx67g1Jj7qDFRKhMs5t

## TUTORIAL: 

The library consists of two central objects, Universe and Company. 

## Universe: 

#### Building the Universe

We begin by initializing our universe and downloading our sec data packages.

    from equities import Universe
    u = Universe()

#### Essential Methods 

To get the number of companies in the universe call: 
    len(u)

To get a dataframe of XBRL metadata from of all companies in the universe call: 

    u.properties()

"CIK" numbers are the sec's official unique identifier for public companies. To get a full list of the cik numbers call:

    u.ciks()

#### Accessing Companies

Universe objects are indexable by "CIK" integers. As an example, to access the first company in the universe call: 

    first_cik = universe.ciks()[0]
    u[first_cik] # This returns an Company object.

## Company: 

A Company object should be thought of as an abstract representation of a real company. Every 
company must have an associated Universe of origin. 

    from equities import Company

#### Accessing the Financial Statements

Consider the first Company in our universe, universe[u.ciks()[0]]. It is a Company object. 

    c = u[u.ciks()[0]]

Dataframes of the company's financial statements over the universe in question is given by: 

    c.income()      # income statement dataframe

    c.balance()     # Balancesheet dataframe

    c.cash()        # Cash Flow Statement dataframe

    c.equity()      # Consolidated Equity dataframe


#### Additional Company Details 

To get the XBRL metadata for a given company as a pandas series call: 

    c.properties()
    
#### Example 

I really want to demonstrate the beauty of this dataset since this is often difficult when looking
at thousands of numeric datatables. Let's take a very naive peek by plotting various statements 
as a kind of stacked timeseries. 

The following is a start to finish example of how one might plot the financial statements 
of the first three companies in the universe.

To perform this experiment, run the following: 

    from equities import test
    test()

Here is the code that this function executes: 

    import pandas as pd
    from equities import Universe, Company
    import matplotlib.pyplot as plt

    u = Universe()
    u.build()
    
    k,f,s = 'bar',(20,10),True
    for cik in u.ciks()[:3]:

        u[cik].income().T.plot(
            kind=k,
            figsize=f,
            stacked=s)

        u[cik].cash().T.plot(
            kind=k,
            figsize=f,
            stacked=s)

        u[cik].balance().T.plot(
            kind=k,
            figsize=f,
            stacked=s)

    plt.show()
rcvpapi 1.6.4
Module to interact with Arista CloudVision

## CloudVision API (rCVP API)

This is a custom CVP API wrapper.  This module works using Python2 and Python3.  

### Support

***NOTE*** Always test on lab deployments before working on a production environment.  Espeically between different releases of CVP and rCVP API.

This has been tested on CVP versions:
- 2018.2.X
- 2019.1.X
- 2020.1.X

### Usage

***NOTE***
The documentation below is incomplete and a work in progress.  This module has more functionality than what is documented.  With the right supplemental data and steps, it can configure CVP from nothing to functioning.

Install using the Python Package Index

```
pip install rcvpapi
```
or 
```
pip3 install rcvpapi
```

#### Initial Setup and Usage

```
from rcvpapi.rcvpapi import *

# Create connection to CloudVision
cvp_cnt = CVPCON(cvp_ip,cvp_user,cvp_user_pwd)

# Check current CloudVision sessionId/Cookie
cvp_cnt.SID

# Get the current CVP Version
cvp_cnt.version

# Logout/End session
cvp_cnt.execLogout()

# Save topology
cvp_cnt.saveTopology()
```

#### Devices/Inventory
```
# Get all provisioned devices
cur_inv = cvp_cnt.getDeviceInventory()

# Adds new devices to inventory/provisioning
cvp_cnt.addDeviceInventory(['10.0.0.1','10.0.0.2'])
```

#### Tasks
```
# Get a list of any Task type
cur_tasks = cvp_cnt.getAllTasks("Pending")

# Get a list of the last 25 Tasks of any type
recent_tasks = cvp_cnt.getRecentTasks(25)

# Execute all tasks
cvp_cnt.execAllTasks("Pending")

# Get status of a task
tsk_stat = cvp_cnt.getTaskStatus(task_id)
```

#### Configlets
```
# Import static configlet
cvp_cnt.impConfiglet("static",configlet_name,configlet_data)

# Import configlet builder
cvp_cnt.impCofniglet("builder",configlet_name,configlet_data,configlet_form_data)

# Get all Configlets
exist_configlets = cvp_cnt.getConfiglets()

# Get a Configlet by Name
ex_cfg = cvp_cnt.getConfigletByName("Base_Authentication")
```

#### Snapshots
```
# Get all configured snapshots
cvp_cnt.snapshots

# Add a new snapshot
# Parameters:
#        snap_name = Name of the snapshot (required)
#        snap_cmds = Array of all commands to be included in snapshot (required)
#        snap_devices = Array of any devices to be included on the snapshot (optional)
cvp_cnt.createSnapshot(snap_name,snap_cmds,snap_devices)
```

#### Containers
```
# Get all containers
ex_cont = cvp_cnt.getAllContainers()

# Add a new container
cvp_cnt.addContainer(new_cont_name,parent_cont_name)
```
openplantbook 0.0.2
OpenPlantbook provides access to the OpenPlantbook API

# OpenPlantbook
Open Plantbook is a free service to access plant data. Anyone can use information from the database for any purpose without limitations.



## Requrements
In order to use this API you need to login to Open Plantbook web UI at https://open.plantbook.io and generate API credentials. The credentials are client_id and client_secret. API authentication implements OAuth2 standard Client Credentials Grant flow.

## Usage
```
import asyncio

from openplantbook import OpenPlantBookApi

client_id = "xxxx"
secret = "yyyy"

api = OpenPlantBookApi(client_id=client_id, secret=secret)

async def get_plant(species):
    plant = await api.get_plantbook_data(species=species)
    return plant

def main():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    result = loop.run_until_complete(get_plant("coleus 'marble'"))
    print(result)

main()
```
PyGrids 1.2.1
Dimensional Data Manipulation and Spreadsheet-like pretty grids.

# PyGrids

## Description
PyGrids is an module for storing and manipulating spreadsheet-like or grid-like information in python.
It also uses numpy to speed up array operations.

## Example
```py
from grids import Grid

grid = Grid(5,3) # Create an empty 5x3 grid.

print(grid.get_cell(5,3)) # -> ∅ None
print(grid.get_cell(3,1)) # -> ∅ None

grid.update_cell(5,3,'Foo')
grid.update_cell(3,2,'Bar')

print()
print(grid.view())
```
Will output...
```py
∅ 
∅

∅      ∅      ∅      ∅      ∅     
∅      ∅      'Bar'  ∅      ∅     
∅      ∅      ∅      ∅      'Foo' 
```

## Installation
```bash
$ pip install pygrids
```

## ``Grid`` Usage
Here's how you can use PyGrids.

### Using cells
**Getting cells**
```py
grid.get_cell(<x>, <y>)
```

**Updating cells**
```py
grid.update_cell(<x>, <y>, <new_value>)
```

**Overviewing cells**
```py
print(grid.view())
```

**Iterating through cells**
> By Columns
```py
for column in grid.y_by_x():
    for cell in column:
        print(x)
```
> By Rows
```py
for row in grid.x_by_y():
    for cell in row:
        print(y)
```

### Saving `Grid`s
You can save your grids by using their built-in ``save()`` method.
```py
# Saves by default to grid1.dat or grid2.dat if that's taken or grid3.dat if grid2.dat it taken, etc.
grid.save()
# Or you can specify a specify a specific filename
grid.save(filename='mygrid.dat')
```

### Loading `Grid`s from file
You can also load your grids into python by using `Grid`'s static ``load()`` method like so.
```py
grid = Grid.load('mygrid.dat')
```

## ``GridLog``'s
Each grid object tracks when it's methods are used and logs them to it's unique ``GridLog`` object. Let's take a look from out first example, what it's log would look like.
```py
print(grid.log)
```
Looks something like
```py
[GridLog created at [2020-10-21 20:30:11.230139]]:
-> [GET_CELL] (5, 3) at [2020-10-21 20:30:11.230171]
-> [GET_CELL] (3, 1) at [2020-10-21 20:30:11.230233]
-> [UPDATE_CELL] (5, 3, 'Foo') at [2020-10-21 20:30:11.230270]
-> [UPDATE_CELL] (3, 2, 'Bar') at [2020-10-21 20:30:11.230286]
-> [LOG_VIEW] () at [2020-10-21 20:30:11.230401]
```

## ``MultiDimensionalArray``'s
Unlike grids, which are constrained to only 2 dimensions, `MultiDimensionalArray`s support arrays of any shape.

```py
from grids import MultiDimensionalArray

myshape = [3,2,4,5]

array = MultiDimensionalArray(myshape)
```

Keep reading for how to use it

## MultiDimensionalArray Usage
Here's a few example's on how use MultiDimensionalArray's

### Updating and Getting Cells
```py
target_coord = [1,2,3,4]

array.update_cell(target_coord, 'Foo')

print(array.get_cell(target_coord)) # Foo
```

## License
This software is licensed by an MIT License.
example-pkg-pro-dach 0.0.1
A small example package
Requires Python: >=3.6

# Foobar

Foobar is a Python library for dealing with word pluralization.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

```bash
pip install foobar
```

## Usage

```python
import foobar

foobar.pluralize('word') # returns 'words'
foobar.pluralize('goose') # returns 'geese'
foobar.singularize('phenomena') # returns 'phenomenon'
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)