semvec/pypi-packages huggingface dataset:
plot-eye-diagram 0.1.0
A library designed to generate and visualize eye diagrams for digital communication signals.
Requires Python: >=3.6

# plot_eye_diagram

`plot_eye_diagram` is a Python library designed to generate and visualize eye diagrams for digital communication signals. The library provides functions to create various types of filters, generate signals, and plot eye diagrams to analyze the quality of the signal transmission.

>>> It mainly comes with three functions. get_filter() , get_signal(),  drawFullEyeDiagram()

>>> get_filter(name,T,rolloff= None): 

    Generate a filter function.

    Parameters:
    name (str): The type of filter to generate ('rect', 'rc', 'rrc').
    T (float): Symbol period.
    rolloff (float, optional): Roll-off factor for 'rc' and 'rrc' filters.

    Returns:
    function: A function representing the specified filter.

    Available Filters:
    - 'rect': Rectangular filter.
    - 'rc': Raised cosine filter.
    - 'rrc': Root raised cosine filter.
    

>>>get_signal(data,g):


    Generate a signal by convolving the data with the provided filter.

    Parameters:
    data (array-like): Input binary data stream.
    g (function): Filter function.

    Returns:
    tuple:
        t (numpy.ndarray): Time vector.
        x (numpy.ndarray): Generated signal.

>>>def drawFullEyeDiagram(x):

    Generate and plot the eye diagram of the signal.

    Parameters:
    x (numpy.ndarray): Input signal.

    Returns:
    None. The function plots the eye diagram.




## Features

- Generate Rectangular, Raised Cosine, and Root Raised Cosine filters.
- Convolve input binary data streams with specified filters to create modulated signals.
- Visualize eye diagrams for analyzing signal integrity and performance.

## Sample usage:

  >>>import plot_eye_diagram as eye
  >>>import numpy as np
  >>>Fs=10
  >>>T=1
  >>>N=10
  >>>b=np.random.randint(0,2,N)
  >>>data=2*b-1
  >>>t=np.arange(-3*T,3*T,1/Fs)
  >>>g=eye.get_filter('rc',T,rolloff=0.2)
  >>>t,x=eye.get_signal(data,g)
  >>>eye.drawFullEyeDiagram(x)

  

## Installation

You can install `plot_eye_diagram` via pip:

```bash
pip install plot-eye-diagram
spectromancer 0.1.8
spectromancer.py is a wizard for managing MAGE spectrum observations of white dwarfs
Requires Python: >=3.8

# spectromancer
spectromancer is a wizard for managing MAGE spectrum observations of white dwarfs. It expects a directory structure in the form:
```
observations/
├── target1/
|   ├── exposure1.fits
│   ├── exposure2.fits
│   └── exposure1.fits
├── target2/
│   ├── exposure1.fits
│   ├── exposure2.fits
│   └── exposure3.fits
└── obsfile.csv
```
Then, spectromancer can be used to automatically coadd the spectra and measure parameters. Each target should have its own folder, which contains all of its individual exposures. The file `obsfile.csv` can contain any information, but must have a column called `name` that corresponds to the name of each target. An example observation and obsfile are provided in the repository. Then, spectromancer can be called from the command line or imported as a python module.

```
usage: spectromancer [-h] [--measure-rvs] [-o [OUTFILE]] [-v] path

spectromancer.py is a wizard for managing MAGE spectrum observations of white dwarfs

positional arguments:
  path                  path to the observation folder

options:
  -h, --help            show this help message and exit
  --measure-rvs         append RVs to the observation table?
  -o [OUTFILE], --outfile [OUTFILE]
                        file to which to write the observation table
  -v, --verbose         save plots?
```
pubid2bib 0.0.1
Command line tool to create BibTeX bibliographic entries for given publication identifiers
Requires Python: >=3.8

# pubid2bib

pubid2bib (Publication Identifier to BibTeX) is a command line tool to fetch bibliographic
entries for given publication identifiers using online services offered by
PubMed, DOI and Google.


## Usage:

```bash
pubid2bib publicationId1 publicationId2 ... publicationIdN
```

Where publicationIds are well formed PMIDs or DOIs for scientific papers
or ISBNs for books.

Example:

```bash
pubid2bib 31726262 10.1021/acs.jced.5b00684 0735619670
```

Will create three BibTeX files in the current path, named:
  - "Removal of dental alloys and titanium attenuates trace metals and
     biological effects on liver and kidney.bib"
  - "Thermodynamic Properties of R-227ea, R-365mfc, R-115, and R-13I1.bib"
  - "Code Complete.bib"

The filenames will be the publication's titles and the
bibliographic entries will conform to Bibtex @article and @book
formats.

## Install

pubid2bib is a standalone Python script. You need Python 3 installed and you
need to be able to execute Python scripts on your platform.


## Inspiration

The fantastic web service <a href="http://www.bioinformatics.org/texmed/">TexMed</a>
allows to search scientific articles in PubMed and create BibTex bibliographic
entries for them. This was the inspiration for *pubid2bib*.

In one sense, *pubid2bib* is more limited, it needs you to find the publication
identifiers first, to create the BibTex entries. But, it is more general in another
sense, because you can use DOIs for published scientific articles that are not found
in PubMed and also ISBNs for books. Furthermore, *pubid2bib* can be called from
scripts.


## Scripting

### From bash

Asumming you have a file called publications.txt with publication identifiers in each line, e.g.:

```text
38942015
38917788
38935715
```

You can have a bash script that calls pubid2bib for each identifier:
```bash
#!/bin/bash

input="publications.txt"

while read -r pmid
do
    echo "${pmid}"
    pubid2bib "${pmid}"
done < "$input"
```

### From Python

You can use the function *dispatch* for each identifier
```python
#!/usr/bin/env python


if __name__ == '__main__':
    from pubid2bib import dispatch
    with open('publications.txt', 'r') as file_object:
        try:
            paperIds = file_object.readlines()
            for pid in paperIds:
                print(pid[:-1])
                dispatch(pid[:-1])
        except (IOError, OSError):
            print('Error reading file')
```


## Abbreviations

PMID: <a href="https://en.wikipedia.org/wiki/PubMed#PubMed_identifier">PubMed identifier</a>

DOI: <a href="https://www.doi.org/the-identifier/what-is-a-doi/">Digital Object Identifier</a>

ISBN: <a href="https://en.wikipedia.org/wiki/ISBN">International Standard Book Number</a>
auto-hash-separator 0.2
Python package for inserting hash separators between functions and classes.

Auto_Hash_Separator is a Python package designed to automate the insertion of hash separators 
    between functions and classes within Python files. This tool enhances code readability by visually separating 
    distinct sections of code, improving maintainability and collaboration in development projects.

    Features:
    🔍 Automatically inserts hash separators in Python files.
    📁 Supports processing of single files, all Python files in a directory, or specific directories.
    🛠️ Enhances code organization and readability.
    🚀 Lightweight and easy-to-use.

    Auto_Hash_Separator is ideal for developers looking to streamline code organization and maintain clean, 
    structured Python projects. Whether you're working on a small script or a large-scale application, 
    Auto_Hash_Separator helps you maintain clarity and structure in your codebase.

    Visit our [GitHub repository](https://github.com/bantoinese83/Code_separator) for more information and to get 
    started with Auto_Hash_Separator today!
amazed 1.0.2
amazed is a package meant for maze generation & solving.

# amazed

Maze generation & solver in one. Simply put, just _a maze(d)_.
**Still in active development!**

Capable of both generating mazes of any rectangular size and solving them using various algorithms.

## Generation
There are multiple ways of creating a maze:
* Depth First Search using recursion
* Hunt and Kill
* Binary Tree
* Random Kruskal
* Aldous Broder
* Random Carving
* Boulder (also named Cinnamon Bun)
## Solvers
- Depth First Search 
- Depth First Search Randomized
- Depth First Search Heuristic
- Lee
- A*
## Visualization
Each generated maze can be exported either as a simple image (all possible formats from `pillow`) or as a GIF (_will be available `v0.0.3`_), where the carving process can be observed. For solvers, each one can be exported either as an image or as a GIF, with a red line (the color is configurable) displaying the chosen path.
valc 1
Wrapper for VALORANT's client API
Requires Python: >=3.0

# valclient.py

### API wrapper for VALORANT's client API

## Installation
```python
pip install valc
```

## Example

```python
from valc import Client

client = Client(region="na")
client.activate()

name = "" #NAME
tag = "" #TAG FOR THE NAME

client.party_invite_by_display_name(name, tag)
```
bvalclient 2.3
Wrapper for VALORANT's client API
Requires Python: >=3.0

# valclient.py

### API wrapper for VALORANT's client API

[![Discord](https://img.shields.io/badge/discord-join-7389D8?style=flat&logo=discord)](https://discord.gg/uGuswsZwAT)
[![Downloads](https://pepy.tech/badge/valclient)](https://pepy.tech/project/valclient)

## Installation
```python
pip install bvalclient
```

## Example

```python
from valclient.client import Client

client = Client(region="na")
client.activate()

# get MatchID of latest match
history = client.fetch_match_history(queue_id="unrated")
print(history["History"][0]["MatchID"])
```
draw-eye-diagram 0.1.0
A library designed to generate and visualize eye diagrams for digital communication signals.
Requires Python: >=3.6

# draw_eye_diagram

`draw_eye_diagram` is a Python library designed to generate and visualize eye diagrams for digital communication signals. The library provides functions to create various types of filters, generate signals, and plot eye diagrams to analyze the quality of the signal transmission.

>>> It mainly comes with three functions. get_filter() , get_signal(),  drawFullEyeDiagram()

>>> get_filter(name,T,rolloff= None): 

    Generate a filter function.

    Parameters:
    name (str): The type of filter to generate ('rect', 'rc', 'rrc').
    T (float): Symbol period.
    rolloff (float, optional): Roll-off factor for 'rc' and 'rrc' filters.

    Returns:
    function: A function representing the specified filter.

    Available Filters:
    - 'rect': Rectangular filter.
    - 'rc': Raised cosine filter.
    - 'rrc': Root raised cosine filter.
    

>>>get_signal(data,g):


    Generate a signal by convolving the data with the provided filter.

    Parameters:
    data (array-like): Input binary data stream.
    g (function): Filter function.

    Returns:
    tuple:
        t (numpy.ndarray): Time vector.
        x (numpy.ndarray): Generated signal.

>>>def drawFullEyeDiagram(x):

    Generate and plot the eye diagram of the signal.

    Parameters:
    x (numpy.ndarray): Input signal.

    Returns:
    None. The function plots the eye diagram.




## Features

- Generate Rectangular, Raised Cosine, and Root Raised Cosine filters.
- Convolve input binary data streams with specified filters to create modulated signals.
- Visualize eye diagrams for analyzing signal integrity and performance.

## Sample usage:

  >>>import draw_eye_diagram as eye
  >>>import numpy as np
  >>>Fs=10
  >>>T=1
  >>>N=10
  >>>b=np.random.randint(0,2,N)
  >>>data=2*b-1
  >>>t=np.arange(-3*T,3*T,1/Fs)
  >>>g=eye.get_filter('rc',T,rolloff=0.2)
  >>>t,x=eye.get_signal(data,g)
  >>>eye.drawFullEyeDiagram(x)

  

## Installation

You can install `draw_eye_diagram` via pip:

```bash
pip install draw-eye-diagram
fagi-tcs 0.1.1
We help GenAI teams maintain high-accuracy for their Models in production.
Requires Python: >=3.6

# TFC

We help GenAI teams maintain high-accuracy for their Models in production
Purpose Built, Scalable & 10X faster than traditional methods

We know that GenAI teams struggle with ensuring optimal performance in production. We are simplifying this by streamlining the process and empowering AI teams to focus on what they do best—developing exceptional AI models

Get evaluation without 
Human-in-the-Loop or Ground Truth

## Installation

You can install this package using pip:

```bash
pip install tfc
pip install git+https://github.com/future-agi/clients