semvec/pypi-packages huggingface dataset:
pure-data 0.1.6.6
Pure Data Framework
Requires Python: >=3.10

# Pure Data
Developed by students of the [Simulator ML (Karpov.Courses)](https://karpov.courses/simulator-ml)

Pure Data is a tool designed to help organize data quality checks in your projects.
You simply define the data you want to test, the list of test metrics and success criteria, run the test, and get a report with the results.

The Pure Data includes:
* a list of different metrics that you can use to check the accuracy of the data;
* Report class, with which you can iterate through a list of metrics and get some summary information about which metrics pass, fail, or drop with errors.

## How to install
```bash
pip install pure-data
```

## Key Functionality
There are plenty of metrics that you can use to control your data's accuracy and reliability.\
You can either just apply the metrics you need to your data or use the **Report** class to create a checklist with metrics you'd like to check and get summary information about the metrics results.

<img src="https://drive.google.com/uc?id=1IVn9xubBaCNcf_ln3wLlhEzvCyG5clmj"
     alt="Pure application diagram"
     style="display: block; margin-right: auto; margin-left: auto; width: 45%" />

## Usage
Below is a brief example of how you can use Pure to verify your data.

Import **Report** class and metrics from which you can use any metrics you need.
```python
from pure.report import Report
import pure.metrics as m
```

Firstly, initialize tables with names and data you want to work with, and create a checklist with metrics.

**Metric** returns a dict with some meta fields. In the checklist, you can specify which metric result fields you want to control within certain limits.
In this example, we will determine limits for the "total" field in the first case and the "delta" field in the second one. 

```python
tables = {"simple_table": data}
checklist = [
    ("simple_table", m.CountTotal(), {"total": (1, 1e6)}),
    ("simple_table", m.CountZeros("column_1"), {"delta": (0, 0.3)})
]
```
Then you can use **Report** just as follows
```python
report = Report(tables=tables, checklist=checklist, engine='pandas')
```

Example of the report resulting dataframe:

<img src="https://drive.google.com/uc?id=16vehJx6HWJGlmfFaY_gjO5oL2FBOZUe_"
     alt="Report dataframe"
     style="display: block; margin-right: auto; margin-left: auto; width: 88%" />

There is a more detailed example where the key functionality of the package is presented:\
https://github.com/uberkinder/Pure-Data/blob/usage_example/examples/simple_example.ipynb
pyhcl 0.4.5
HCL configuration parser for python

pyhcl
=====

Implements a parser for `HCL (HashiCorp Configuration
Language) <https://github.com/hashicorp/hcl>`__ in Python. This
implementation aims to be compatible with the original golang version of
the parser.

pyhcl does not support HCL2 (which is what modern terraform uses). You might try
https://pypi.org/project/python-hcl2/ instead (though I've never personally tried it).

The grammar and many of the tests/fixtures were copied/ported from the
golang parser into pyhcl. All releases are tested with a variety of 
python versions from Python 2.7 onward.

This version has been modified to work with terraform 0.12 syntax.  
It should be backward compatible with earlier versions.  
It doesn't cover every situation.  See discussion in pull request:
https://github.com/virtuald/pyhcl/pull/57

Installation
============

::

    pip install pyhcl

Usage
=====

This module is intended to be used in mostly the same way that one would
use the json module in python, and load/loads/dumps are implemented.

::

    import hcl

    with open('file.hcl', 'r') as fp:
        obj = hcl.load(fp)

Currently the dumps function outputs JSON, and not HCL.

Convert HCL to JSON
-------------------

pyhcl comes with a script that you can use to easily convert HCL to JSON,
similar to the json.tool that comes with python::

	hcltool INFILE [OUTFILE]
	
Structure Validation
--------------------

Similar to JSON, the output of parsing HCL is a python dictionary with
no defined structure. The golang library for HCL implements support for
parsing HCL according to defined objects, but this implementation does
not currently support such constructs.

Instead, I recommend that you use tools designed to validate JSON, such
as the `schematics <https://pypi.python.org/pypi/schematics>`_ library. 

Syntax
======

-  Single line comments start with ``#`` or ``//``

-  Multi-line comments are wrapped in ``/*`` and ``*/``

-  Values are assigned with the syntax ``key = value`` (whitespace
   doesn't matter). The value can be any primitive: a string, number,
   boolean, object, or list.

-  Strings are double-quoted and can contain any UTF-8 characters.
   Example: ``"Hello, World"``

-  Numbers are assumed to be base 10. If you prefix a number with 0x, it
   is treated as a hexadecimal. If it is prefixed with 0, it is treated
   as an octal. Numbers can be in scientific notation: "1e10".

-  Boolean values: ``true``, ``false``

-  Arrays can be made by wrapping it in ``[]``. Example:
   ``["foo", "bar", 42]``. Arrays can contain primitives and other
   arrays, but cannot contain objects. Objects must use the block syntax
   shown below.

Objects and nested objects are created using the structure shown below::

    variable "ami" {
        description = "the AMI to use"
    }

Testing
=======

To run the tests::

    pip install -r testing-requirements.txt
    tests/run_tests.sh
    
Debug Mode
----------

To enable debug mode::

    import hcl
    hcl.parser.DEBUG = True

Authors
=======

Dustin Spicuzza (dustin@virtualroadside.com)

Note: This project is not associated with Hashicorp
pterobot 0.0.1
A Discord bot for viewing and controlling Pterodactyl servers
Requires Python: >=3.7

# pterobot

PteroBot is a Discord bot that can be used to view and control your 
Pterodactyl game servers.

PteroBot also has a hosted version in addition to the open source 
self-hosted version.  To join PteroBot to your server immediately navigate 
to https://pterobot.net.

## Getting Started

There are a few easy ways to get started using PteroBot.

### Install from pip

Install from pip by running `pip install pterobot`

### Using Docker

Get the Docker image from `ghcr.io/iamkubi/pterobot`

### Using Pterodactyl

Get the Pterodactyl egg from `https://github.com/iamkubi/eggs/pterobot`
versionedfunction 0.9.57
Sometimes you want to be able to dynamically call different versions of a function
Requires Python: >=3.8,<4.0

# versionedfunction
Sometimes you want to be able to dynamically call different 
versions of a function.
* testing alternatives against each other
* runtime "always on" support for versions code changes

## Example

```python
from versionedfunction import versionedfunction, versionedcontext


class Foo():
    @versionedfunction
    def algo(self):
        return 0

    @algo.version
    def algo1(self):
        return 1

    @algo.version
    @algo.default
    def algo2(self):
        return 2


foo = Foo()

# the default is algo2
assert foo.algo() == 2

with versionedcontext(Foo.algo):
    # choose Foo.algo
    assert foo.algo() == 0

@versionedcontext(Foo.algo1)
def some_method():
    assert foo.algo() == 1
```

## Installing
```bash
$ pip install versionedfunction
```
The source code is currently hosted on GitHub at 
https://github.com/GistLabs/versionedfunction
and published in PyPI at https://pypi.org/project/versionedfunction/ 

The versioning scheme currently used is {major}.{minor}.{auto build number}
from `git rev-list --count HEAD`. 

We recommend picking a version like:

`versionedfunction = "^0.9"`

## Community guidelines
We welcome contributions and questions. Please head over to github and 
send us pull requests or create issues!