semvec/pypi-packages huggingface dataset:
signal-ICT-KaavyaRao-92510133009 1.0.0
A Python package for fundamental signal processing operations
Requires Python: >=3.7


This Package demonstrates the fundamental concepts of Signals and Systems by implementing various unitary signals, trigonometric signals, and signal operations in a modular way. The project also includes a main.py script that showcases how to use these modules with the help of tasks.

---

Folder Structure:
signal_ICT_KaavyaRao_92510133009/
│
├── init.py
├── unitary_signals.py
├── trigonometric_signals.py
├── operations.py
│
├── main.py


---

Modules and Functions

1. unitary_signals.py
Implements basic discrete signals:
- unit_step(n) - Generates a unit step signal.
- unit_impulse(n) - Generates a unit impulse signal.
- ramp_signal(n) - Generates a ramp signal.

Each function:
- Returns a NumPy array
- Plots the signal using Matplotlib

---

2. trigonometric_signals.py
Implements continuous-time signals:
- sine_wave(A, f, phi, t) - Generates a sine wave
- cosine_wave(A, f, phi, t) - Generates a cosine wave
- exponential_signal(A, a, t) - Generates an exponential signal

---

3. operations.py
Implements signal operations:
- time_shift(signal, k) - Shifts signal by *k* units
- time_scale(signal, k) - Scales time axis by factor *k*
- signal_addition(signal1, signal2) - Adds two signals
- signal_multiplication(signal1, signal2) - Multiplies two signals point-wise

---

Main Script (main.py)
Demonstrates:
1. Generate and plot unit step and unit impulse signals (length = 20).
2. Generate and plot a sine wave (A=2, f=5 Hz, phase=0, t=0–1 sec).
3. Perform time shifting on sine wave (+5 units).
4. Perform addition of unit step and ramp signal.
5. Multiply a sine and cosine wave of same frequency.
signal-ICT-Keshvi-92510133028 1.0.0
A Python package for fundamental signal processing operations
Requires Python: >=3.7

signal_ICT_Keshvi_92510133028/
│── __init__.py
│── unitary_signals.py         # Unit step, unit impulse, ramp
│── trigonometric_signals.py   # Sine, cosine, exponential
│── operations.py              # Time shift, time scale, add, multiply
main.py                        # Demo script
pyproject.toml                 # Packaging details
README.md                      # Documentation


This models will display:
Unitary signals → step, impulse, ramp
Trigonometric signals → sine, cosine
Exponential signals → growth & decay
Operations → time shift, scaling, addition, multiplication

### 1. `unitary_signals.py`
Implements **basic discrete-time signals**:
- `unit_step(n)` – Generates a unit step signal.
- `unit_impulse(n)` – Generates a unit impulse signal.
- `ramp_signal(n)` – Generates a ramp signal.

### 2. `trigonometric_signals.py`
Implements **continuous-time signals**:
- `sine_wave(A, f, phi, t)` – Generates a sine wave with amplitude `A`, frequency `f`, phase `phi`, and time vector `t`.
- `cosine_wave(A, f, phi, t)` – Generates a cosine wave.
- `exponential_signal(A, a, t)` – Generates an exponential signal (growth/decay).

### 3. `operations.py`
Implements **signal operations**:
- `time_shift(signal, n, k)` – Shifts a signal by `k` units (delay/advance).
- `time_scale(signal, n, k)` – Scales a signal’s time axis by factor `k`.
- `signal_addition(signal1, signal2)` – Adds two signals element-wise.
- `signal_multiplication(signal1, signal2)` – Multiplies two signals element-wise.

### 4. `main.py`
Main script to demonstrate:
1. Generate and plot a unit step and unit impulse signal (length 20).  
2. Generate a sine wave of amplitude 2, frequency 5 Hz, phase 0, over `t = 0 to 1 sec`.  
3. Perform time shifting on the sine wave by +5 units and plot both original and shifted signals.  
4. Perform addition of unit step and ramp signals.  
5. Multiply a sine and cosine wave of same frequency and plot the result.
opengine2 2.0.1
A text box that allows easier input of many characters in a structured way.
Requires Python: >=3.12

# opengine2

A text box that allows easier input of many characters in a structured way.

Start typing in the text box.
Alternatives for each character typed is accessed in series
by repeatedly typing the same character,
like in an __o__ld __p__hone (hence the name).
As you type, gain feedback with which character you just typed in the display.
Finish by pressing "Quit & Copy",
which copies the text box's contents to the clipboard.

[Demonstration video here.][1]

[1]: https://youtu.be/5XY7_RqjlBo

# Defining your own keyboards
By default an IPA keyboard is complete
and a partial Cyrillic and Greek keyboard is also provided
for proof of concept of keyboard switching.

To write your own keyboard,
put them in your XDG data path.
TOML and HOCON are supported.
The filename should end in `.opengine2.toml` or `.opengine2.hocon`
as needed.

Only three keys are needed in either case:

- `opengine2_version` defines the file as an opengine2-readable file
  and sets the version.
  This is always 1 for now.
- `name` gives the name as displayed in the GUI.
- `keys` is a list of two- or three-element lists.
  Characters are typed in the order of their appearance in the keyboard file.
  - The first element is the key that the character is assigned to.
  - The second element is the key that the character can type
  - The third element, if present, is the name that will be displayed as a hint.
    If missing, then the hint is the Unicode name of the character.

TOML is useful for machine generation.
If you handwrite your own keyboards,
HOCON is better because you don't need to type so many quotes.

The location for storing the files is still in flux
and may change as future versions require.

# Configuration file
Not yet implemented,
but the following keys are expected:

- `keyboards`: locations of additional keyboard files.
- `default_kbd`: name of default file.

It is placed in the usual location,
i.e. `~/.config/opengine2` or wherever your XDG environment variables are set.

# Possibly Asked Questions
## Why not an IME? ##
Mostly because I can't quite figure out how to make it (`ibus`) work,
but also because this is fairly unusual behaviour for an IME.
Generally an IME would not demand repeated entry of a key to switch alternatives.

## Why version 2? ##
Version 1 was an AutoHotkey script.
It's well over 10 years old now but it is still usable.
However, AHK is poorly supported on Linux
so I had to make something else to replace it.
eastinstaller24 1.0.0
EastInstaller24 - a lightweight pip wrapper CLI
Requires Python: >=3.7

\# EastInstaller24



\*\*EastInstaller24\*\* is a lightweight Python package manager CLI built on top of `pip`, created by \*\*Xscripts, Inc. (BB)\*\*.  

It gives you quick commands like `ea install <pkg>` instead of typing long `pip` commands.



---



\## 🚀 Installation



Clone this repo and install it locally:



```bash

pip install -e .



\# ⚠️ NOTE

\# If the ea command doesn’t work, you can try:

\# python a.py install <pkg>

\# Or if that still doesn’t work:

\# a.py install <pkg>

\# This applies to all commands, not just install