semvec/pypi-packages huggingface dataset:
EasyCo 0.2.3
Easy configuration with yaml files
Keywords: yaml,yml,config,configuration,file

# EasyCo
[![Build Status](https://travis-ci.org/spacemanspiff2007/EasyCo.svg?branch=master)](https://travis-ci.org/spacemanspiff2007/EasyCo)
[![Documentation Status](https://readthedocs.org/projects/easyco/badge/?version=latest)](https://easyco.readthedocs.io/en/latest/?badge=latest)

_Easy Configuration with yaml files_

# Goal
The goal of **EasyCo** is to provide an **easy** way of **Co**niguration using yaml files for Python programs.
It can automatically create a default configuration from provided default values and will validate the provided data.

# Documentation
[The documentation can be found at here](https://easyco.readthedocs.io)

# Example

```python
from EasyCo import ConfigFile, ConfigContainer

class MyContainer(ConfigContainer):
    SubValueA: int
    SubValueB: int = 7

class MyConfigFile(ConfigFile):
    ConfValueA: int = 5
    ConfValueB: float = 5.5

    sub_values = MyContainer()
    
cfg = MyConfigFile('test')
cfg.load()
```
PyConsole-JasonTheDev 1.0.0
A Tkinter GUI Console For Executing Commands.
Requires Python: >=3.6

# PyConsole By JasonTheDev

PyConsole Is A Developer Console That Lets Your User Or The Developers To Have A Console Interface For Testing.
This Comes Extreamly Handy When You Want To Execute Functions At Certain Times And Don't Want To Write Too Much Code.

There Will Be A "Command" Class Which Is A Class That Stores A Function/Method That Gets Called When The Command Is Executed And A 
Name Which Is The Name Thats Used To Call The Command In The Console (Note: The Commands Will Be Lowered So Even A Command Like
"eXiT" will be recognised as "exit").

The Console Will Be A Tkinter Window And It Supports Custom GUI Made In Tkinter But the feature is not tested and polished so there
may be bugs. There must be these components on the tkinter window if you decide to use the custom GUI feature:

"CommandEntry" - tkinter.Entry Used For Entering Commands

"CommandList" - tkinter.Listbox Used For Displaying Commands

"SubmitButton" - tkinter.Button Used For Submitting Commands

Note: The Return/Enter button will automatically be binded to execute commands.

Usage Examples (Python Code):

```Python
from PyConsole.Console import Console, Command

console = Console("Console title", "icon path", "background color code") # Create a new console.   all these parameters are optional

def function(): # The Function That Will Get Activated When A Command Is Executed
	print("A Command Has Been Executed Through PyConsole")
	console.WriteLine("You Just Executed A Command") # Writing A Line To The Console

cmd = Command("name", function) # Created a Command Object Called cmd and giving it a name and a function/method to call

# The Name Of The Command Will Be the text used to call the command

console.RegisterCommand(cmd) # Register The Command That We Just Created, You Could Register As Many As You Want

console.mainloop() # Calls the tkinter.mainloop() function
```
smartlens-smartlens 0.9.0
A Python library for the SmartLens API.
Requires Python: >=3.6

# SmartLens Python Library

The SmartLens Python library provides convenient access to the SmartLens API from
applications written in the Python language. Integrate state-of-the-art AI into your application
in just five lines of code.

## Documentation

See the [API docs](https://smartlens.ai/docs).

## Installation

To install the package, simply run:

```sh
pip install smartlens
```

### Requirements

-   Python 3.6+

## Usage

The library needs to be configured with your account's API key which is
available in the [SmartLens Dashboard][api-keys]. Set `smartlens.api_key` to its
value:

```python
import smartlens
smartlens.api_key = "YOUR-API-KEY"

# tag image
tags = smartlens.tagImage(
    image = "path/to/my/image"
)

# caption image
captions = smartlens.captionImage(
    image = "path/to/my/image"
)

# process document
extractedItems = smartlens.runDocumentAI(
    document = "path/to/my/document",
    customExtractions = [{'natural_language_query': 'What is the salary?', 'answer_key': 'employee_salary'}] # Custom extractions are optional
)

# process text document
extractedItems = smartlens.runTextAnalysis(
    text = "path/to/my/text",
    customExtractions = [{'natural_language_query': 'What is the salary?', 'answer_key': 'employee_salary'}] # Custom extractions are optional
)
```

[api-keys]: https://dashboard.smartlens.ai

<!--
# vim: set tw=79:
-->
plottoterminal 1.0
Plotting library for the terminal.

# plot**to**terminal
A plotting utility (library) for plotting data into the terminal encoded as
unicode characters as an xy graph, inspired by matplotlib. This tool doesn't
have any dependencies on gnuplot or numpy.

Supports:
* multi scatter plots
* automatic tick setting for linear scales
* automatic data rescaling to fit large numbers as tick labels
* axis labels
* unit labels
* command line interface for plotting xy data file (`$ plottoterminal file`)

Planned:
* command line interface for xy(z) data plotting
* bar plot
* legends
* z value heatmap
* color coding support
* custom marker styles

Example:
```python
import plottoterminal as ptt
import numpy as np

f = ptt.Figure(figsize=(57, 20))
xs = np.linspace(-10, 10, 200)

ys = xs ** 2
f.scatter(xs, ys)

ys2 = -xs ** 2
f.scatter(xs, ys2)

f.set_x_label("x")
f.set_y_label("x*x")
f.set_x_unit("m")
f.set_y_unit("m^2")
f.show()
```

Output:
```
   1.0ᐃxx                                         xx     
×10^2 │ xx                                       xx      
[m^2] │  xxx                                   xxx       
      │    xx                                 xx         
   0.5├      xx                             xx           
      │       xxxx                       xxxx            
      │          xxx                   xxx               
x     │             xxxx           xxxx                  
*  0.0├                *************                     
x     │             ****           ****                  
      │          ***                   ***               
      │       ****                       ****            
  -0.5├      **                             **           
      │    **                                 **         
      │  ***                                   ***       
      │ **                                       **      
  -1.0├**                                         **     
      └┴──────────┴──────────┴──────────┴──────────┴────ᐅ
       -1.0       -0.5       0.0        0.5        1.0   
                                x               ×10^1 [m]
```

## Setup
Installing from source:

```shell script
git clone https://github.com/bitromortac/plottoterminal
cd plottoterminal
python3 -m pip install --user .
```

Installing from pypi:
```shell script
python3 -m pip install --user plottoterminal
```

## Command line usage
To plot a file composed of rows of x and y data separated by whitespace,
run the command `$ plottoterminal file.xy`.
asol-probability-dist 0.2
A package to visualize Gaussian and Binomial probability distributions

# asol_probability_dist


## Table of Contents
* [Purpose](#purpose)
* [List of key files](#list_of_key_files)
* [Python Libraries](#python_libraries)
* [Creator](#creators)

## Purpose

This is a Python package that creates gaussian and binomial distribution objects. Plotting functions are included to visualize the probability distribution functions. Values for distributions can be read in line by line from text file.


## List_of_key_files

* **Binomialdistribution.py** - Binomial distribution class and methods.
* **Gaussiandistribution.py** - Gaussian distribution class and methods.
* **Generaldistribution.py** - General distribution class and methods.


## Python_Libraries

* math
* matplotlib


## Creators

* Andrew Leung
    - [https://github.com/as2leung](https://github.com/as2leung)
sigmet 0.9.0
A Python package to find and measure negative price shocks in financial time-series data
Requires Python: >=3.6

# sigmet
![Github Tests](https://github.com/agupta01/sigmet/workflows/Python%20Tests/badge.svg)
[![Documentation Status](https://readthedocs.org/projects/sigmet/badge/?version=latest)](https://sigmet.readthedocs.io/en/latest/?badge=latest)
[![GitHub license](https://img.shields.io/github/license/agupta01/sigmet.svg)](https://github.com/agupta01/sigmet/master/LICENSE)

Installation
------------
Sigmet (Signal Metrics Toolkit) is an end-to-end solution for the detection and measurement of negative shocks in time series data.

Sigmet requires the following packages: 

- Pandas: primary data format for easy data manipulation and datetime functionality
- Numpy: for computation
- Statsmodels: AU3 uses statsmodel’s ARIMA and SARIMAX models for prediction
- Matplotlib: plotting for .graph() method



To install, run the following on the command line

```
pip install sigmet
```


Example
-------

First we instantiate an AU3 object

```python
from sigmet import Sigmet
    
data = pd.read_csv('time-series.csv')
ex = Sigmet(start, end, data)
ex.fit(window_start, window_end)

# graph the result as follows
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax = ex.graph()
plt.show()
```

Contribute
----------

- Issue Tracker: https://github.com/agupta01/sigmet/issues
- Source Code: https://github.com/agupta01/sigmet

License
-------

The project is licensed under the GNU General Public License.
landbosse 2.3.0.3
LandBOSSE
Requires Python: >=3.6

[![Build Status](https://travis-ci.com/WISDEM/LandBOSSE.svg?branch=pip_installable)](https://travis-ci.com/WISDEM/LandBOSSE)

# LandBOSSE

## Welcome to LandBOSSE!

The Land-based Balance-of-System Systems Engineering (LandBOSSE) model is a systems engineering tool that estimates the balance-of-system (BOS) costs associated with installing utility scale wind plants (10, 1.5 MW turbines or larger). It can execute on macOS and Windows. At this time, for both platforms, it is a command line tool that needs to be accessed from the command line.

The methods used to develop this model (specifically, LandBOSSE Version 2.1.0) are described in greater detail the following report:

Eberle, Annika, Owen Roberts, Alicia Key, Parangat Bhaskar, and Katherine Dykes.
2019. NREL’s Balance-of-System Cost Model for Land-Based Wind. Golden, CO:
National Renewable Energy Laboratory. NREL/TP-6A20-72201.
https://www.nrel.gov/docs/fy19osti/72201.pdf.

## User Guides

First, read the technical report to understand the big picture of LandBOSSE. In the technical report, you will find process diagrams, equations and the modules that implement them. Then, come back to this documentation and read the user guide.

In brief, LandBOSSE takes `.xlsx` spreadsheets, reads input data from tabs on the spreadsheets, and writes the results to an output `.xlsx` file. There are three sections in the user guide to demonstrate how to perform these steps.

The user guide comes in three parts:

1. Software installation,

2. Input data configuration, and

3. Output data analysis.

### Software Installation

There are two options depending on whether you are a developer or an end user and what operating system you are running.

- **Windows end-user**: If you run the Microsoft Windows operating system and aren't setting up as a developer who is going to be modifying the core library, these instructions are for you. [Find out how to configure Windows for end users.](installation_instructions/windows_end_user.md)

- **macOS end user** and **macOS developer**: If you run the macOS operating system, either as an end-user or as a developer, these instructions are for you. Both developers and end-users will need most of the steps. [Find out how to configure macOS for end users and developers.](installation_instructions/macos_developer.md)

### Operation after the installation

Review the installation instructions on how to activate a virtual environment, if you haven't already.

Then, read the [Operation and Folder Structure](installation_instructions/operation_and_folder_structure.md) for details on running the command that executes LandBOSSE from the command line.