semvec/pypi-packages huggingface dataset:
unitary-customer-common 0.1.0
A dummy package to prevent dependency confusion
Requires Python: >=3.8

# unitary-customer-common

This is a placeholder package published on PyPI to prevent dependency confusion attacks. This package is not intended for actual use.

## Purpose

This package exists solely to reserve the package name on PyPI, protecting against potential supply chain attacks through dependency confusion.

## Installation

```bash
pip install unitary-customer-common
```

## Usage

This package contains no meaningful functionality and should not be used in production.
pygame-canvas 1.7.1
A library for canvas operations using pygame
Requires Python: >=3.6

Canvas
Canvas is a Python module built on top of Pygame, designed to simplify the creation of interactive applications and games. It provides a set of functions and classes for managing graphical elements, handling user input, and implementing game logic.

Features
Window Management: Create resizable windows with customizable properties such as title, size, and icon.
Event Handling: Capture user input events like mouse clicks, keyboard presses, and window resizing.
Sprite Management: Define and manipulate sprites with properties like position, scale, rotation, and collision detection.
Text Rendering: Render text with customizable fonts, sizes, colors, and antialiasing options.
Sound Playback: Play sounds with adjustable volume and manage sound effects associated with sprites.
Physics Simulation: Implement basic physics interactions such as collision resolution and object movement.
Usage
Installation
To use Canvas, you'll need Python installed on your system along with the Pygame library. You can install Pygame using pip:


pip install pygame

# Example Usage
Here's a simple example demonstrating how to use Canvas to create a window and display a sprite:

import pygame_canvas as c

c.default_template(__file__)

The code above will load a default template into the main python script OVERWRITING EVERYTHING ELSE

Documentation
For detailed documentation and usage examples, refer to the Canvas documentation at: https://docs.google.com/document/d/18SMSY5RbigaOX2WOaGQs0iEUvSFnpfpWjsBxBNwq0nA/edit?usp=sharing.
scikit-comm 0.1.0
Routines to simulate communication systems
Requires Python: >=3.11

# scikit-comm: simulation toolbox for communication systems

This python package contains a collection of DSP routines and algorithms to perform numerical simulations on simple communication systems. Its functionality is divided into transmitter, channel, and receiver subsystems and - at its current state - contains very limited functionalities.

This project was initially started by [Lutz Molle](https://www.htw-berlin.de/hochschule/personen/person/?eid=12017) and [Markus Nölle](https://www.htw-berlin.de/hochschule/personen/person/?eid=9586) at the [University of Applied Sciences (HTW), Berlin](https://www.htw-berlin.de/).

# Installation

## Installation via pip

The current stable version of this package can be installed via pip using the following command

```python
pip install scikit-comm
```

## Installation from GitLab repository

Further, the current development status can be installed by cloing the repository and installing locally via pip using the following commands

```python
git clone https://gitlab.com/htw-ikt-noelle/scikit-comm.git
cd scikit-comm
```

and then either regular install with 

```python
python -m pip install ./
```

or install in "editable" mode with

```python
python -m pip install -e ./
```

# Sources of information

The documentation can be found at [Readthedocs](https://scikit-comm.readthedocs.io), while the code is hosted at [GitLab](https://gitlab.com/htw-ikt-noelle/scikit-comm).

# General overview and first steps

## The 'signal' object
The 'signal' object can be seen as the 'heart of the toolbox'. It contains all information to describe a modulated data signal. The object can consist of multiple 'dimensions', while each dimension represents in general a two dimensional (or complex) data signal. The structure looks as follows:

```python
def Signal:    
  self.n_dims
  self.samples
  self.center_frequency
  self.sample_rate
  self.bits
  self.symbols
  self.symbol_rate
  self.modulation_info
  self.constellation
```

Many modules and methods take this signal object as input or output variables. Others in contrast take only a subset of the signal attributes (e.g. the sampled signal (sig.samples)) as input or output.

## Package structure

Besides the signal object, there are multiple other modules avaialable, which provide different functionalities for the simulation of a communication system:

| Module                | Description | 
| :---                  | :---        |
|skcomm.channel                |basic function to emulate a transmission channel|
|skcomm.filters | method to filter a discrete signal |
|skcomm.instrument_control | methods to communicate with laboratory equipment | 
|skcomm.pre_distortion |methods to perform identification and pre-distortion of linear systems| 
|skcomm.rx| receiver (dsp) subfunctions| 
|skcomm.tx| transmitter (dsp) subfuntions | 
|skcomm.utils| utility functions (mostly used by other methods) | 
|skcomm.visualizers| methods to visualize the data signal |