semvec/pypi-packages huggingface dataset:
reg2info 1.0.0
An awesome package that allows getting meaningful information from a Linear regression model

# Reg2info

![version](https://img.shields.io/badge/version-1.0.0-blue)  ![Python](https://img.shields.io/badge/Language-Python-green) ![Contributions welcome](https://img.shields.io/badge/contributions-welcome-orange.svg) [![License](https://img.shields.io/badge/license-MIT-red.svg)](https://opensource.org/licenses/MIT) 

**reg2info** is a Python package for getting meaningful information from a Linear regression model.




## Table of content

- [Installation](#where-to-get-it)
- [Dependencies](#dependencies)
- [Main Features](#pmain-features)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)

##  Where to get it

Binary installers for the latest released version are available at the  [Python Package Index (PyPI)](https://pypi.org/project/reg2info)

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

```bash
pip install reg2info
```
## Dependencies
- Numpy
- Matplotlib

## Main Features
- A linear regression line has an equation of the form **_Y = a + bX_**, where **_X_** is the explanatory variable and **_Y_** is the dependent variable. The slope of the line is **_b_**, and **_a_** is the intercept (the value of **_y_** when **_x_** = 0).

- A regression line is the “best fit” line for your data. You basically draw a line that best represents the data points. It’s like an average of where all the points line up. In linear regression, the regression line is a perfectly straight line.

## Usage 

```python
import reg2info as r2i

lr = LinearRegression().fit(X_train, y_train)

# returns equation
eq = r2i.reg_equation(lr)

# returns line and data plot
plot = r2i.reg_plot(lr,X_train[feature], y_train)
```



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


## License
[MIT](https://choosealicense.com/licenses/mit/)
pybitbucketapi 1.0.1
pybitbucketapi facilitates the usage of bitbucket apis inside a python module or in command line
Requires Python: >=3.6, <4
Keywords: pybitbucketapi

# pybitbucketapi

pybitbucketapi contains some functions to facilitate the usage of bitbucket apis inside python modules or in command line.

[The source for this project is available here][src].

---

Example of importing bitbucketapi inside a python module :

    import os
    from pygitlabapi import gitlabApi

    iurl = "https://gitlab.com/api/v4"
    ijson = "project.json"
    imethod="POST"
    iapi = "/projects"
    iuser= os.environ.get("GITLAB_USER")
    itoken = os.environ.get("GITLAB_TOKEN")
    message= gitlabApi.rungitlabApi(api=iapi, method=imethod, url=iurl, user=iuser, token=itoken, json=ijson )
    print(message)

---

[packaging guide]: https://packaging.python.org
[distribution tutorial]: https://packaging.python.org/tutorials/packaging-projects/
[src]: https://github.com/stormalf/pybitbucketapi
[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional


## Release notes

1.0.0 Initial version

1.0.1 Managing http error codes
pyskytapapi 1.0.2
pyskytapapi facilitates the usage of skytap apis inside a python module or in command line
Requires Python: >=3.6, <4
Keywords: pyskytapapi

# pyskytapapi

pyskytapapi contains some functions to facilitate the usage of skytap apis inside python modules or in command line.

[The source for this project is available here][src].

---

Example of importing skytapapi inside a python module :

    import os
    from pyskytapapi import skytapApi

    iurl = "https://cloud.skytap.com"
    ijson = "configurations.json"
    imethod="POST"
    iapi = "/configurations.json"
    iuser= os.environ.get("SKYTAP_USER")
    itoken = os.environ.get("SKYTAP_TOKEN")
    message= skytapApi.runskytapApi(api=iapi, method=imethod, url=iurl, user=iuser, token=itoken, json=ijson )
    print(message)

---

[packaging guide]: https://packaging.python.org
[distribution tutorial]: https://packaging.python.org/tutorials/packaging-projects/
[src]: https://github.com/stormalf/pyskytapapi
[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional


## Release notes

1.0.0 Initial version

1.0.2 Managing http error codes
leopardi 0.2.24
An extensible library for generating 3D synthetic data with Blender that just works.
Requires Python: >=3.5
Keywords: synthetic data blender 3d machine learning rendering images yolo coco pascal voc

# Leopardi 
*An extensible library for generating 3D synthetic data with Blender that just works.*
Requires Python >= 3.0, Blender >= 2.80

Leopardi aims to make it easy to create robust synthetic images by importing scenes into Blender. It takes care of the boring, strenuous, and difficult stuff so that you can devote your time to training and evaluating your machine learning models.

**NOTE: Leopardi is currently in a pre-alpha change. Breaking changes (though unlikely) may occur.**

## Backgrounds 
Backgrounds are imported from a specified directory (which defaults to ./backgrounds/) and merges them with the rendered image.

## Camera 
The Leopardi Camera extends Blender's default camera with a variety of options for choosing camera location, lens size, sensor size, and more.

## Models 
Similarly to backgrounds, models are imported from a specified directory (which defaults to ./models/) and are used to render a synthetic image.

## Renderer
The renderer allows for specifying which labels to generate to accompany an image, which Blender rendering engine to use, as well as the resolution of the rendered images. 

## Examples
Below is a dead-simple demonstration of working with Leopardi on Windows to generate a single render.

```python
import leopardi

BLENDER_DIR = "C:\Program Files\Blender Foundation\Blender 2.92"

camera = leopardi.LeopardiCamera()
lighting = leopardi.LeopardiLighting()
renderer = leopardi.LeopardiRenderer()
model_loader = leopardi.ModelLoader()
background_loader = leopardi.BackgroundLoader()

engine = leopardi.Leopardi(camera, lighting, renderer, background_loader, model_loader)
engine.render(1)
```

If we want to include a depth map and YOLO annotations with our renders, we do so as below

```python
import leopardi

BLENDER_DIR = "C:\Program Files\Blender Foundation\Blender 2.92"

camera = leopardi.LeopardiCamera()
lighting = leopardi.LeopardiLighting()
renderer = leopardi.LeopardiRenderer(labels=["DEPTH", "YOLO"])
model_loader = leopardi.ModelLoader()
background_loader = leopardi.BackgroundLoader()

engine = leopardi.Leopardi(camera, lighting, renderer, background_loader, model_loader)
engine.render(1)
```
pygitlabapi 1.0.1
pygitlabapi facilitates the usage of gitlab apis inside a python module or in command line
Requires Python: >=3.6, <4
Keywords: pygitlabapi

# pygitlabapi

pygitlabapi contains some functions to facilitate the usage of gitlab apis inside python modules or in command line.

[The source for this project is available here][src].

---

Example of importing gitlabapi inside a python module :

    import os
    from pygitlabapi import gitlabApi

    iurl = "https://gitlab.com/api/v4"
    ijson = "project.json"
    imethod="POST"
    iapi = "/projects"
    iuser= os.environ.get("GITLAB_USER")
    itoken = os.environ.get("GITLAB_TOKEN")
    message= gitlabApi.rungitlabApi(api=iapi, method=imethod, url=iurl, user=iuser, token=itoken, json=ijson )
    print(message)

---

[packaging guide]: https://packaging.python.org
[distribution tutorial]: https://packaging.python.org/tutorials/packaging-projects/
[src]: https://github.com/stormalf/pygitlabapi
[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional

## Release notes 

1.0.0 Initial version

1.0.1 Managing http error codes
obscure-password 1.0.3
Self contained obfuscation of hardcoded passwords in Python scripts.
Requires Python: >=3.6, <4
Keywords: password,obfuscation,obscure,development

# obscure-password

[![Python package](https://github.com/Shapedsundew9/obscure-password/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/Shapedsundew9/obscure-password/actions/workflows/python-package.yml)
[![codecov](https://codecov.io/gh/Shapedsundew9/obscure-password/branch/main/graph/badge.svg?token=ZDKW1280KN)](https://codecov.io/gh/Shapedsundew9/obscure-password)

## Overview

obscure-password is a self contained obfuscation library for hardcoded passwords (or other text) in Python scripts. Obfuscation is a technique to prevent the unskilled or casual observer access to sensitive data and provide an impediment to the skilled i.e. requiring explicit effort to circumvent.
Typical use cases are in casual software development or  debugging where a developer may be sharing scripts with field technicians to perform one-off tasks.

## Usage

```python
>>> from obscure_password import obscure, unobscure
>>> obscured = obscure('my sensitive information')
>>> print(obscured)
fxFpdVRHWRJjTkFnN0lmMTQ7NSslBB4jby8kMgofJFU5Lz0A
>>> unobscure(obscured)
'my sensitive information'
```

obscure_password laces the obscured text with a marker which enables it to avoid unobscuring text that has not been obscured.

```python
>>> from obscure_password import obscure, unobscure
>>> unobscure('my sensitive information')
'my sensitive information'
```

This is helpful when developing a script and wanting to regularly change the password.

## Limitations

- Ofuscation is NOT secure!
- obscure-password was designed for password obfuscation and not to obscure large texts. The base64 encoding increases the obscured text length by x1.25 plus 16 characters, for the marker, over the original text length.
- The text size obscured / unobscured is unrestricted (limited by RAM & patience). As a first approximation for large texts memory required is +1.25x the original text size.

## Sunburst Code Coverage Chart

 The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

 ![Sunburst](https://codecov.io/gh/Shapedsundew9/obscure-password/branch/main/graphs/sunburst.svg)