semvec/pypi-packages huggingface dataset:
pyemfield 0.1.6
A Python library for HFSS antenna radiation pattern analysis and gain optimization
Requires Python: >=3.6

# pyemfield: Python Antenna Radiation Analysis and Optimization Library

`pyemfield` is a Python library designed for antenna radiation pattern analysis and gain optimization. The package leverages SciPy, NumPy, Matplotlib, and ANSYS HFSS (via `pyaedt`) to automate high-frequency structure simulations, process electromagnetic data, and visualize results.

## Key Features
- **Gain Calculation and Optimization**: Provides methods to calculate antenna gain with multiple optimization options, including exhaustive, heuristic, and SciPy-based optimizations.
- **Radiated Power Density and Cumulative Distribution**: Calculates and visualizes cumulative distribution functions (CDFs) for radiation characteristics.
- **Custom Radiation Pattern and Gain Distribution Plots**: Offers multiple plotting functions to visualize radiated power density, gain, and other related data.
- **Integration with HFSS**: Automates the export of far-field data from HFSS simulations for further analysis and optimization.

## Installation

You can install the package using `pip`:

```bash
pip install pyemfield
```

> **Note**: Ensure that `pyaedt` and ANSYS HFSS are installed to fully utilize all functionalities in this package.

## Dependencies
This package requires the following libraries:
- `numpy`
- `scipy`
- `matplotlib`
- `pyaedt`

## Quick Start

### 1. Basic Usage Example

The following example demonstrates how to use `pyemfield` to calculate and visualize antenna gain:

```python
from pyemfield import hfss_design, get_ffds, Beam

folder = r'D:\OneDrive - ANSYS, Inc\GitHub\pyemfield\tests\ffds'
ffds = get_ffds(folder)

ffds.keys()

x = {j:(1,0) for i, j in ffds.items()}
b1 = Beam(x)

b1.ffd_excitation
b2 = b1.optimize_gain(60, 60)
b2.plot_realized_gain_contour()
b2.ffd_excitation

hd.update_excitation(b2.ffd_excitation)
```

![2024-11-03_09-12-52](/assets/2024-11-03_09-12-52.png)

### 2. Create a Custom Plane and Plot Cumulative Distribution

```python
# Set up multiple beams and create a Plane
plane = create_plane("MyPlane", beam, [(0, 0), (90, 90)], fast=True)
plane.plot_rGain_cdf()
plane.plot_eirp_cdf()
```
pydipole 0.0.1
Table of dipole polarizaility for atom with Z=1 to 120
Requires Python: >=3.8
Keywords: dipole polarizability, periodic table

# Pydipole
[![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://docs.python.org/3.8/)
[![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://docs.python.org/3.9/)
[![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://docs.python.org/3.10/)
[![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)](https://docs.python.org/3.11/)
[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://docs.python.org/3.12/)

<div align="center">
  <img src="./docs/pydipole.svg"  width="150px" />
</div>

[`Pydipole`](https://github.com/AtomPolarTable/dipole-polarizability) is a Python package to maintain Table of atomic dipole polarizability for neutural atoms in the Periodic Table.

This version contains contributions from:
Peter Schwerdtfeger (1)
Jeffrey K. Nagle (2)
YingXing Cheng (3),

- (1) Centre for Theoretical Chemistry and Physics, Massey University, Auckland, New Zealand.
- (2) Department of Chemistry, Bowdoin College, Brunswick, ME, USA.
- (3) Numerical Mathematics for High-Performance Computing (NMH), University of Stuttgart, Stuttgart, Germany.

The `pydipole` source code is hosted on GitHub and is released under the GNU General Public License v3.0.
Please report any issues you encounter while using the `pydipole` library on [GitHub Issues](https://github.com/AtomPolarTable/dipole-polarizability/issues/new).
For further information and inquiries, please contact us at yxcheng2buaa@gmail.com.

## Tables

- The 2023 Table is available [here](https://github.com/AtomPolarTable/dipole-polarizability/blob/main/tables/2023/main.pdf).

## License

![GPLv3 License](https://img.shields.io/badge/license-GPLv3-blue.svg)


`pydipole` is distributed under GPL License version 3 (GPLv3).

## Dependencies

The following dependencies will be necessary for `pydipole` to build properly,

* pandas : https://github.com/pandas-dev/pandas


## Installation

To install `pydipole` with version `0.0.x`:

```bash
pip install pydipole
```

To install latest `pydipole`:

```bash
git clone http://github.com/AtomPolarTable/dipole-polarizability
cd dipole-polarizability
pip install .
```

To run test, one needs to add tests dependencies for `tests`:

```bash
pip install .[tests]
```

For developers, one could need all dependencies:
```bash
pip install -e .[dev,tests]
```

## Citations

Please use the following citations in any publication using `pydipole` library:

[1] Schwerdtfeger, P.; Nagle, J. K.
**2018 Table of static dipole polarizabilities of the neutral elements in the periodic table.**
Molecular Physics 2019, 117 (9-12), 1200–1225.
[![DOI: 10.1080/00268976.2018.1535143](https://img.shields.io/badge/DOI-10.1080/00268976.2018.1535143-blue)](https://doi.org/10.1080/00268976.2018.1535143)
medialink 0.1.3
Medialink is a Python CLI-tool for bringing order to your digital film and tv-show library.
Requires Python: <4.0,>=3.10

<p align="center">
    <img width="200" align="center" src="https://raw.githubusercontent.com/anhede/medialink/refs/heads/main/medialink.png" alt="Medialink logo">
</p>
<h1 align="center">Medialink</h1>
Medialink is a Python CLI-tool for bringing order to your digital film and tv-show library. From a messy collection of badly structured folders and files, Medialink can generate a new folder structure with properly named files and folders for use with services such as Plex, Emby, and Jellyfin. Medialink uses links to the original files, so no files are copied or moved. Since the original files are not modified or moved, it allows torrents and other downloads to continue seeding without interruption.

## Installation
### pipx (Recommended)
Medialink can be installed using pipx, which is a tool to install Python CLI tools in isolated environments. This is the recommended way to install Medialink as it will not interfere with other Python packages on your system.
```bash
pipx install medialink
```

### pip
Medialink can also be installed using pip, which is the Python package installer. This is not recommended as it will install Medialink globally on your system and may interfere with other Python packages.
```bash
pip install medialink
```

## Usage

```bash
python cli.py [OPTIONS] SOURCE [TARGET]
```

### Arguments

- `SOURCE` (required): The path to the source directory to scan for films and/or shows. Must exist and be readable.
- `TARGET` (optional): The path to the target directory to populate. Must not exist prior unless specified elsewhere.

### Options

- `-tf, --target-films <path>`: Specify the target directory for films. Must not already exist.

- `-ts, --target-shows <path>`: Specify the target directory for TV shows. Must not already exist.

- `-d, --dry-run`: Perform a dry run of the operation without making any changes.

- `-v, --verbose`: Enable verbose output for detailed information during the execution.

- `--version`: Show the version of the CLI tool.

- `--help`: Show help message and usage information.

### Examples

1. **Basic Usage**:
   ```bash
   python cli.py /path/to/source /path/to/target
   ```

2. **Scan with Target Films Directory**:
   ```bash
   python cli.py /path/to/source --target-films /path/to/films
   ```

3. **Dry Run with Verbose Output**:
   ```bash
   python cli.py /path/to/source --dry-run
   ```

## Developers
If you want to contribute to Medialink, you can clone the repository and install the development dependencies using poetry. Remember to use the `--with=dev` flag to install the development dependencies.
```bash
git clone
cd medialink
poetry install --with=dev   # Installs dev dependencies.
poetry run medialink --help # Run the tool!
```

## License
Medialink is licensed under the GPL-3.0-or-later License. See [LICENSE](LICENSE) for more information.
rasim-project 0.1.0
A short description of the package

- 👋 Hi, I’m @rasimh542
- 👀 I’m interested in ...
- 🌱 I’m currently learning ...
- 💞️ I’m looking to collaborate on ...
- 📫 How to reach me ...

<!---
rasimh542/rasimh542 is a ✨ special ✨ repository because its `README.md` (this file) appears on your GitHub profile.
You can click the Preview link to take a look at your changes.
--->
pluralizefr 0.1.1
pluralize for french language
Requires Python: >=3.8

================
French Pluralize
================

Convert a singular word into plural according french grammar rules.
Plural to singular is available too (but some special cases are probably missing).


Usable as Jinja2 filter.

Licence
-------

BSD license (see LICENCE file)


Features
--------

1. Python code example:

.. code-block:: python

    import pluralizefr
    pluralizefr.pluralize("fromage") # return fromages
    pluralizefr.singularize("fromages") # return fromage


2. Jinja2 exemple:

.. code-block:: jinja2

    {{ 'fromage' | pluralize }}

Installation
------------

The package is available at:
https://pypi.org/project/pluralizefr/

Install it with:

.. code-block::

    pip install pluralizefr
list-utilities 0.1.1
A Python package for common list operations such as removing duplicates and flattening lists.
Requires Python: >=3.6

 List Utilities

List Utilities is a simple Python package that provides utility functions for common list operations, including removing duplicates and flattening nested lists.

Installation

You can install the package using pip:

pip install list_utilities


Functions Descriptions

First Function: remove_duplicates(input_list)
Description: This function takes a list as input and returns a new list that contains the unique elements from the original list, preserving their original order. It effectively removes any duplicate entries without altering the sequence of the remaining items.

Parameters:
input_list (list): A list of elements from which duplicates need to be removed. The elements can be of any data type (e.g., integers, strings).
Returns:

(list): A list containing only unique elements from the input_list.

Example:
 
from list_utilities import remove_duplicates

my_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = remove_duplicates(my_list)
print(unique_list)  

Output:
 
[1, 2, 3, 4, 5]

Second Function: flatten_list(nested_list)
Description: This function flattens a nested list, which may contain other lists at any level of depth, into a single list. It recursively traverses through all elements and sub-elements, collecting them into a single flat structure.

Parameters:

nested_list (list): A list that may contain other lists as elements. The nesting can be at multiple levels.
Returns:

(list): A single list that includes all elements from the nested_list, with no nesting.
Example:

from list_utilities import flatten_list

nested = [[1, 2], [3, 4, [5, 6]], 7]
flat = flatten_list(nested)
print(flat) 

Output:

[1, 2, 3, 4, 5, 6, 7]


License
This project is licensed under the MIT License - see the LICENSE file for details.