electrocute 0.1.0__tar.gz

electrocute-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: electrocute
+Version: 0.1.0
+Summary: A Python library for electronic formulas and signal processing
+Home-page: https://github.com/madhurthareja/electrocute
+Author: Madhur Thareja
+Author-email: madhurthareja1105@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Electrocute
+
+**Electrocute** is a Python library designed for electronic formulas and signal processing. It provides easy-to-use functions for calculations like Ohm's Law, power, FFT, DFT, and filters, making it ideal for engineers, students, and hobbyists.
+
+---
+
+## Installation
+
+```bash
+pip install electrocute
+```
+
+## Usage
+
+```python
+from electrocute import Electrocute
+
+# Calculate voltage using Ohm's Law
+voltage = Electrocute.ohms_law(current=2, resistance=5)
+print(f"Voltage: {voltage} V")  # Output: 10 V
+
+import numpy as np
+from electrocute import Electrocute
+
+t = np.linspace(0, 1, 1000, endpoint=False)
+signal = np.sin(2 * np.pi * 10 * t)
+freqs, amps = Electrocute.frequency_spectrum(signal, sampling_rate=1000)
+```
+
+## Features
+
+- Electronic formulas (Ohm's Law, power calculations, etc.)
+- Signal processing (FFT, DFT, frequency spectrum, filters)
+- Extensible and well-documented API
+
+## Contributing
+
+Contributions are welcome! Please submit a pull request or open an issue on GitHub.
+
+### Maintainers:
+This library is under development and is actively maintained by Madhur Thareja.
+
+## License
+
+MIT License

electrocute-0.1.0/README.md

@@ -0,0 +1,45 @@
+# Electrocute
+
+**Electrocute** is a Python library designed for electronic formulas and signal processing. It provides easy-to-use functions for calculations like Ohm's Law, power, FFT, DFT, and filters, making it ideal for engineers, students, and hobbyists.
+
+---
+
+## Installation
+
+```bash
+pip install electrocute
+```
+
+## Usage
+
+```python
+from electrocute import Electrocute
+
+# Calculate voltage using Ohm's Law
+voltage = Electrocute.ohms_law(current=2, resistance=5)
+print(f"Voltage: {voltage} V")  # Output: 10 V
+
+import numpy as np
+from electrocute import Electrocute
+
+t = np.linspace(0, 1, 1000, endpoint=False)
+signal = np.sin(2 * np.pi * 10 * t)
+freqs, amps = Electrocute.frequency_spectrum(signal, sampling_rate=1000)
+```
+
+## Features
+
+- Electronic formulas (Ohm's Law, power calculations, etc.)
+- Signal processing (FFT, DFT, frequency spectrum, filters)
+- Extensible and well-documented API
+
+## Contributing
+
+Contributions are welcome! Please submit a pull request or open an issue on GitHub.
+
+### Maintainers:
+This library is under development and is actively maintained by Madhur Thareja.
+
+## License
+
+MIT License

electrocute-0.1.0/electrocute/__init__.py

@@ -0,0 +1,3 @@
+from .formulas.basic import BasicFormulas
+from .signal_processing.filters import Filters
+from .signal_processing.transforms import Transforms

electrocute-0.1.0/electrocute/formulas/__init__.py

@@ -0,0 +1 @@
+from .basic import *

electrocute-0.1.0/electrocute/formulas/basic.py

@@ -0,0 +1,21 @@
+class BasicFormulas:
+    @staticmethod
+    def ohms_law(voltage: float = None, current: float = None, resistance: float = None) -> float:
+        """
+        Calculate the missing parameter in Ohm's Law (V = I * R).
+        """
+        if voltage is None and current and resistance:
+            return current * resistance
+        elif current is None and voltage and resistance:
+            return voltage / resistance
+        elif resistance is None and voltage and current:
+            return voltage / current
+        else:
+            raise ValueError("Provide exactly two parameters: voltage, current, or resistance.")
+
+    @staticmethod
+    def power(voltage: float, current: float) -> float:
+        """
+        Calculate electrical power (P = V * I).
+        """
+        return voltage * current

electrocute-0.1.0/electrocute/signal_processing/__init__.py

@@ -0,0 +1,2 @@
+from .filters import *
+from .transforms import *

electrocute-0.1.0/electrocute/signal_processing/filters.py

@@ -0,0 +1,45 @@
+import numpy as np
+from scipy import signal
+
+class Filters:
+    @staticmethod
+    def low_pass_filter(signal_input: np.ndarray, cutoff: float, sampling_rate: float, order: int = 5) -> np.ndarray:
+        """
+        Apply a low-pass Butterworth filter to the input signal.
+        """
+        nyquist = 0.5 * sampling_rate
+        normal_cutoff = cutoff / nyquist
+        b, a = signal.butter(order, normal_cutoff, btype='low', analog=False)
+        return signal.filtfilt(b, a, signal_input)
+
+    @staticmethod
+    def high_pass_filter(signal_input: np.ndarray, cutoff: float, sampling_rate: float, order: int = 5) -> np.ndarray:
+        """
+        Apply a high-pass Butterworth filter to the input signal.
+        """
+        nyquist = 0.5 * sampling_rate
+        normal_cutoff = cutoff / nyquist
+        b, a = signal.butter(order, normal_cutoff, btype='high', analog=False)
+        return signal.filtfilt(b, a, signal_input)
+
+    @staticmethod
+    def band_pass_filter(signal_input: np.ndarray, lowcut: float, highcut: float, sampling_rate: float, order: int = 5) -> np.ndarray:
+        """
+        Apply a band-pass Butterworth filter to the input signal.
+        """
+        nyquist = 0.5 * sampling_rate
+        low = lowcut / nyquist
+        high = highcut / nyquist
+        b, a = signal.butter(order, [low, high], btype='band', analog=False)
+        return signal.filtfilt(b, a, signal_input)
+
+    @staticmethod
+    def band_stop_filter(signal_input: np.ndarray, lowcut: float, highcut: float, sampling_rate: float, order: int = 5) -> np.ndarray:
+        """
+        Apply a band-stop Butterworth filter to the input signal.
+        """
+        nyquist = 0.5 * sampling_rate
+        low = lowcut / nyquist
+        high = highcut / nyquist
+        b, a = signal.butter(order, [low, high], btype='bandstop', analog=False)
+        return signal.filtfilt(b, a, signal_input)

electrocute-0.1.0/electrocute/signal_processing/transforms.py

@@ -0,0 +1,32 @@
+import numpy as np
+from typing import Tuple
+
+class Transforms:
+    @staticmethod
+    def dft(signal_input: np.ndarray) -> np.ndarray:
+        """
+        Compute the Discrete Fourier Transform of the input signal.
+        """
+        N = len(signal_input)
+        n = np.arange(N)
+        k = n.reshape((N, 1))
+        e = np.exp(-2j * np.pi * k * n / N)
+        return np.dot(e, signal_input)
+
+    @staticmethod
+    def fft(signal_input: np.ndarray) -> np.ndarray:
+        """
+        Compute the Fast Fourier Transform of the input signal using NumPy.
+        """
+        return np.fft.fft(signal_input)
+
+    @staticmethod
+    def frequency_spectrum(signal_input: np.ndarray, sampling_rate: float) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Compute the frequency spectrum of the input signal.
+        """
+        N = len(signal_input)
+        fft_result = np.fft.fft(signal_input)
+        frequencies = np.fft.fftfreq(N, 1 / sampling_rate)
+        amplitudes = np.abs(fft_result) / N
+        return frequencies[:N//2], amplitudes[:N//2]

electrocute-0.1.0/electrocute.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: electrocute
+Version: 0.1.0
+Summary: A Python library for electronic formulas and signal processing
+Home-page: https://github.com/madhurthareja/electrocute
+Author: Madhur Thareja
+Author-email: madhurthareja1105@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Electrocute
+
+**Electrocute** is a Python library designed for electronic formulas and signal processing. It provides easy-to-use functions for calculations like Ohm's Law, power, FFT, DFT, and filters, making it ideal for engineers, students, and hobbyists.
+
+---
+
+## Installation
+
+```bash
+pip install electrocute
+```
+
+## Usage
+
+```python
+from electrocute import Electrocute
+
+# Calculate voltage using Ohm's Law
+voltage = Electrocute.ohms_law(current=2, resistance=5)
+print(f"Voltage: {voltage} V")  # Output: 10 V
+
+import numpy as np
+from electrocute import Electrocute
+
+t = np.linspace(0, 1, 1000, endpoint=False)
+signal = np.sin(2 * np.pi * 10 * t)
+freqs, amps = Electrocute.frequency_spectrum(signal, sampling_rate=1000)
+```
+
+## Features
+
+- Electronic formulas (Ohm's Law, power calculations, etc.)
+- Signal processing (FFT, DFT, frequency spectrum, filters)
+- Extensible and well-documented API
+
+## Contributing
+
+Contributions are welcome! Please submit a pull request or open an issue on GitHub.
+
+### Maintainers:
+This library is under development and is actively maintained by Madhur Thareja.
+
+## License
+
+MIT License

electrocute-0.1.0/electrocute.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+electrocute/__init__.py
+electrocute.egg-info/PKG-INFO
+electrocute.egg-info/SOURCES.txt
+electrocute.egg-info/dependency_links.txt
+electrocute.egg-info/requires.txt
+electrocute.egg-info/top_level.txt
+electrocute/formulas/__init__.py
+electrocute/formulas/basic.py
+electrocute/image_processing/__init__.py
+electrocute/signal_processing/__init__.py
+electrocute/signal_processing/filters.py
+electrocute/signal_processing/transforms.py
+tests/test_electrocute.py

electrocute-0.1.0/electrocute.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

electrocute-0.1.0/electrocute.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.21.0
+scipy>=1.7.0

electrocute-0.1.0/electrocute.egg-info/top_level.txt

@@ -0,0 +1 @@
+electrocute

electrocute-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

electrocute-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="electrocute",
+    version="0.1.0",
+    author="Madhur Thareja",
+    author_email="madhurthareja1105@gmail.com",
+    description="A Python library for electronic formulas and signal processing",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/madhurthareja/electrocute",
+    packages=find_packages(),
+    install_requires=[
+        "numpy>=1.21.0",
+        "scipy>=1.7.0",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

electrocute-0.1.0/tests/test_electrocute.py

@@ -0,0 +1,51 @@
+import pytest
+import numpy as np
+from electrocute.formulas.basic import BasicFormulas
+from electrocute.signal_processing.filters import Filters
+from electrocute.signal_processing.transforms import Transforms
+
+def test_ohms_law():
+    assert BasicFormulas.ohms_law(current=2, resistance=5) == 10
+    assert BasicFormulas.ohms_law(voltage=10, resistance=5) == 2
+    assert BasicFormulas.ohms_law(voltage=10, current=2) == 5
+
+def test_power():
+    assert BasicFormulas.power(voltage=10, current=2) == 20
+
+def test_frequency_spectrum():
+    t = np.linspace(0, 1, 1000, endpoint=False)
+    signal = np.sin(2 * np.pi * 10 * t)
+    freqs, amps = Transforms.frequency_spectrum(signal, sampling_rate=1000)
+    assert len(freqs) == 500
+    assert len(amps) == 500
+
+def test_low_pass_filter():
+    t = np.linspace(0, 1, 1000, endpoint=False)
+    signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
+    filtered_signal = Filters.low_pass_filter(signal, cutoff=15, sampling_rate=1000)
+    assert len(filtered_signal) == len(signal)
+    assert np.all(np.abs(filtered_signal) <= 1.5)
+
+def test_high_pass_filter():
+    t = np.linspace(0, 1, 1000, endpoint=False)
+    signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
+    filtered_signal = Filters.high_pass_filter(signal, cutoff=15, sampling_rate=1000)
+    assert len(filtered_signal) == len(signal)
+    assert np.all(np.abs(filtered_signal) <= 1.5)
+
+def test_band_pass_filter():
+    t = np.linspace(0, 1, 1000, endpoint=False)
+    signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
+    filtered_signal = Filters.band_pass_filter(signal, lowcut=5, highcut=15, sampling_rate=1000)
+    assert len(filtered_signal) == len(signal)
+    assert np.all(np.abs(filtered_signal) <= 1.5)
+
+def test_band_stop_filter():
+    t = np.linspace(0, 1, 1000, endpoint=False)
+    signal = np.sin(2 * np.pi * 10 * t) + 0.5 * np.sin(2 * np.pi * 20 * t)
+    filtered_signal = Filters.band_stop_filter(signal, lowcut=5, highcut=15, sampling_rate=1000)
+    assert len(filtered_signal) == len(signal)
+    assert np.all(np.abs(filtered_signal) <= 1.5)
+
+if __name__ == "__main__":
+    pytest.main()