semvec/pypi-packages huggingface dataset:
teg-get-best-n 0.0.7
Estimate the optimal number of components in PCA-based dimension reduction.
Requires Python: >=3.6

Estimate the optimal number of components in a PCA, using the SHEM procedure: Split-Half Eigenvector Matching.

The get_n_components function estimates the true (or "generating") number of principal components. While scree/elbow/knee criteria for the eigenvalues curve is common, this is known to be a very fallible heuristic. The rationale of this alternative procedure is that true principal components should be found in random split halves of the data. The estimate is therefore based on measuring the similarity of eigenvectors between a set of split-halves; i.e., the procedure doesn't use the shape of the eigenvalue curve. Instead, a separation is made between components with high versus low split-half similarity.

Detail: For an nd-array X, with shape == (nObservations, nVariables), a number of random splits are performed. For each split separately, a PCA is performed, via eigendecomposition of the covariance matrix of X. Each of the first split's eigenvectors is matched to the most-similar of the second split's eigenvectors. Similarity is measured via the dot product. The vector of similarities is sorted from high to low, and the vectors are averaged over all random splits. Finally, the optimal seperation between the high versus low similarities is determined by a basic between-within variance criterion. An estimated zero components is possible.

Usage:

O = teg_get_best_n.get_n_components(X)

This returns a dictionary with the estimated number of components in O['nComponents'], as well as the eigenvalues (O['eigenvalues']) and eigenvectors (O['eigenvectors']).

Example.py contains tests with simulated data to check how well the true number of latent variables, used to generate simulated data, is recovered.
spacysee 0.0.4
Visualizer for spaCy NER models
Requires Python: >=3.6

# SpacySee

A project that helps you visualize your Spacy docs in Jupyter notebooks

## Installation

```bash
pip install spacysee
```

## Usage

```python
from spacysee import render

nlp = spacy.load("en_core_web_sm")
doc = nlp("This is a neat way to visualize your Spacy docs")

render(doc, width="500", height="500")
```

## Example

![Example](https://raw.githubusercontent.com/moxley01/spacysee/master/screenshot.png)

## Notes

Each of the dependency tags, POS tags and morphological features are clickable. Clicking on a tag will bring up the relevant documentation for that tag.
archive-repo 0.0.3
Tools for archival of a GitHub repository
Requires Python: >=3.6

# archive-repo
Captures and stores data about a GitHub repo for archival purposes

# Archive command

usage: python3 -m archive-repo archive [-h] [--reference [REFFILE]] [--issues-only] [--quiet] repo githubToken [outFile]

Archive repo issues and PRs.

positional arguments:
- `repo`:  The GitHub repository to fetch, e.g. "quicwg/base-drafts"
- `githubToken`:  A token for a GitHub account with permission to read the
  selected repository; see https://github.com/settings/tokens
- `outfile`:  Where the output should be written; if omitted, stdout is used.

optional arguments:
- `-h`: Displays help text
- `--reference`: Optionally, previous output of this script.  Makes the new run
  faster, since only new/changed issues and PRs need to be fetched.
- `--issues-only`:  Only fetch issues, not PRs
- `--quiet`:  Only write errors to stderr; otherwise, status is written to
  stderr

Note that providing an output file can make processing faster if the respository
has not changed since the reference file was generated.

# Generate PR Branches

usage: python3 -m archive-repo pr_branches [-h] [--include-merged] [--dry-run] input repo git_dir

Identify the source repos and forks of PRs from an archive, creating local branches as needed

positional arguments:
- `input`:  Archive file generated by `python3 -m archive-repo archive`
- `repo`:  Target GitHub repo
- `git_dir`:  Local directory with git repo (default: local directory)

optional arguments:
- `-h`: Display help message
- `--include-merged`: include merged PRs in analysis
- `--dry-run`: Show what would be done, without making any changes
TACalculator-v3 0.4
Simple calculator, performing basic functions


 
 
<h1><p style="font-family: 'Brush Script MT', cursive;">Hello!</h1></p>
For the Module 1 Sprint 1 project I was supposed to create a Python package that is capable of conducting basic calculator-like functions, including:
<li> Addition/ Subtraction;
<li> Multiplication/ Division;
<li> Taking (n) root of a number;
<li> Resetting memory.


<b>IMPORTANT note!</b> Calculator is capable of accepting both integers and float numbers.

## How to use it?

### 1. First of all, let's install the package. It can be accessed both - in your local machine and remote (like Google Colab)
``` shell
pip install TACalculator-v3
```
### 2. Import module "Calculator" from a package

```python
from file.calculator import Calculator
```
### 3. Create an instance of the Calculator class:

```python
calculator = Calculator()
```

*<b>IMPORTANT note</b>: By default calculator's memory is set to 0.0

<h2>Known biases, possible areas for improvement:</h2>

1. <b>Error handling and input validation.</b> It is expected that user will by himself handle possible Errors i. e. (division by Zero, math with string values, etc.)
2. <b>Additional functionality.</b> Calculator can easily have more algebra functions.

<h1> Main functions

## Addition
To add a value to the memory value, use the `add(value)` method. This will add 12.0 to the memory value and will return the new value.
```python
calculator.add(12.0)
```


## Substraction
To subtract a value from the memory value, use the `subtract(value)` method. This will subtract 5.0 from the memory value and will return the new value.
```python
calculator.subtract(5.0)
``` 


## Multiplication
To multiply the memory value by a value, use the `multiply(value)` method. This will multiply the memory value by 6.0 and will return the new value.
```python
calculator.multiply(6.0)
``` 


## Division
To divide the memory value by a value, use the `divide(value)` method. This will divide the memory value by 2.0 and will return the new value.
```python
calculator.divide(2.0)
``` 


## Root
To take the 1/nth root of the memory value, use the `root(value)` method. This will take the third level root of the memory value and will return the new value.
```python
calculator.root(3)
```

## Reset
To reset the memory value to 0.0, use the `reset()` method. This will reset the memory value to 0.0 and will return the 0.0 value.
```python   
calculator.reset()
```


<h2> Thank you for you attention!

I am open for a feedback!
db1 0.1.6
DB1 Python client
Requires Python: >=3.7

# DB1

Store one item in the cloud with one line. No login. Share, visualize and embed live view in Notion.


## Getting started

DB1 is like a global python dict. Upload anything, access anywhere. For Javascript client, CLI and more examples see [documentation](https://db1-io.notion.site/DB1-Documentation-f5942d3984f7456ca49fba70c971bbf6).


### 1. Install
~~~bash
pip install db1
~~~


### 2. Upload and retrieve data
Choose a key and replace 'example_key' with your own.
~~~
from db1 import DB1
import numpy as np

# upload anything
DB1['example_key'] = {
    "message" : "Hey, I'm using DB1! 🤙",
    "temperature" : 21.2421,
    "numbers" : [1, 2, 3, "four"],
    "matrix" : np.eye(5)
}

# retrieve anywhere
my_value = DB1['example_key']
~~~


### 3. View your item in the browser

Go to [https://db1.io/](https://db1.io/) and enter your key in the text field.


### 4. Embed item in Notion

To embed the item above in your Notion page, simply paste the URL [https://db1.io/?key=example_key](https://db1.io/?key=example_key) in any page and click “Create embed”.

Notion [examples](https://db1-io.notion.site/Embed-live-DB1-item-in-Notion-a3b1b8a7face4e9aa1bc527881ffd779#ac1e7313c0334d5cb1859dd02d248aaa).
frange-py 1.0.0
An alternative to range with support for floats
Requires Python: >=3.6

# frange: An alternative to range with support for floats

## Requirements
Python 3.6>=

## Installation
```bash
# Linux
python3 -m pip install frange-py
# Windows
python -m pip install frange-py
```

## Usage
```python
import frange

frange.frange(10.0) # frange(0, 10, 1)
frange.frange(0.5, 10.5) # frange(0.5, 10.5, 1)
len(frange.frange(0.5, 10.5)) # 10
frange.frange(0.5, 10.5)[0] # 0.5
frange.frange(0.5, 10.5)[-1] # 9.5
frange.frange(0.5, 10.5)[1:5] # frange(1.5, 5.5)
for i in frange.frange(0.5, 10.5):
    print(i) 
"""
0.5
1.5
2.5
3.5
4.5
5.5
6.5
7.5
8.5
9.5
"""
```

### Monkey patching the built-in range function
```python
from frange import frange as range
```

## To Do
* [ ] Rewrite in C