semvec/pypi-packages huggingface dataset:
marga-pulseq 0.2.2
A simple interpreter from PulSeq 1.4 to MARGA
License: MIT
Requires Python: >=3.6

# marga_pulseq
Pulseq interpreter for vnegnev's MARcos fpGA (MARGA)

# Usage:
TO INSTALL: this interpreter can be installed from PyPl with `pip install marga_pulseq`

To import the package: `import marga_pulseq.interpreter`

Create interpreter with `marga_pulseq.interpreter.PSInterpreter`. Run `PSInterpreter.interpret()` to get output array and dictionary. Specify a log path to log errors, warnings, and progress.

# Arguments
rf_center (float): RF center (local oscillator frequency) in Hz.

rf_amp_max (float): Default 5e+3 -- System RF amplitude max in Hz.

grad_max (float): Default 1e+6 -- System gradient max in Hz/m.

gx_max (float): Default None -- System X-gradient max in Hz/m. If None, defaults to grad_max.

gy_max (float): Default None -- System Y-gradient max in Hz/m. If None, defaults to grad_max.

gz_max (float): Default None -- System Z-gradient max in Hz/m. If None, defaults to grad_max.

clk_t (float): Default 1/122.88 -- System clock period in us.

tx_t (float): Default 123/122.88 -- Transmit raster period in us. Will be overwritten if the PulSeq file includes a "tx_t" in the definitions.

grad_t (float): Default 1229/122.88 -- Gradient raster period in us. Will be overwritten if the PulSeq file includes a "grad_t" in the definitions.

tx_warmup (float): Default 500 -- Warmup time to turn on tx_gate before Tx events in us. Will be overwritten if the PulSeq file includes a "tx_warmup" in the definitions.

tx_zero_end (bool): Default True -- Force zero at the end of RF shapes

grad_zero_end (bool): Default True -- Force zero at the end of Gradient/Trap shapes

log_file (str): Default 'ps_interpreter' -- File (.log appended) to write run log into

log_level (int): Default 20 (INFO) -- Logger level, 0 for all, 20 to ignore debug.

# Outputs
dict: tuple of numpy.ndarray time and update arrays, with variable name keys

dict: parameter dictionary containing raster times, readout numbers, and any file-defined variables
SIMNet 0.2.0
Modern API wrapper for Genshin Impact & Honkai: Star Rail built on asyncio and pydantic.
License: MIT
Requires Python: <4.0,>=3.9

# Semi-Intransient Matrix Network

Modern API wrapper for Genshin Impact & Honkai: Star Rail built on asyncio and pydantic.

## Requirements

- Python 3.8+
- httpx
- Pydantic

## Example

A very simple example of how SIMNet would be used:

```python3
import asyncio
import simnet

async def main():
    cookies = {} # write your cookies
    player_id = 123456789
    async with simnet.StarRailClient(cookies, player_id=player_id) as client:
        data = await client.get_starrail_user()
        print(f"Player has a total of {data.stats.avatar_num} characters")

asyncio.run(main())
```

## Credits
- [genshin.py](https://github.com/thesadru/genshin.py/): fork source
MongoDBConnPKG 0.0.4
A python package for connecting with database.
License: MIT
Requires Python: >=3.7

# requirements_dev.txt we use for the testing
It makes it easier to install and manage dependencies for development and testing, separate from the dependencies required for production.

# difference between requirements_dev.txt and requirements.txt

requirements.txt is used to specify the dependencies required to run the production code of a Python project, while requirements_dev.txt is used to specify the dependencies required for development and testing purposes.

# tox.ini
We use if for the testing in the python package testing against different version of the python 

## how tox works tox enviornment creation
1. Install depedencies and packages 
2. Run commands
3. Its a combination of the (virtualenvwrapper and makefile)
4. It creates a .tox


# pyproject.toml
it is being used for configuration the python project it is a alternative of the setup.cfg file. its containts configuration related to the build system
such as the build tool used package name version author license and dependencies

# setup.cfg
In summary, setup.cfg is used by setuptools to configure the packaging and installation of a Python projec

# Testing python application
*types of testing*
1. Automated testing 
2. Manual testing

*Mode of testing*
1. Unit testing
2. Integration tests

*Testing frameworks*

1. pytest
2. unittest
3. robotframework
4. selenium
5. behave
6. doctest

# check with the code style formatting and syntax(coding standard)

1. pylint
2. flake8(it is best because it containt 3 library pylint pycodestyle mccabe)
3. pycodestyle
inputx 1.0.3
`inputx` is a Python module that provides an advanced input function with various validation options.
License: MIT
Requires Python: <4.0,>=3.6
Keywords: inputx, inputs, input, advanced input, custom input, enhanced input, filtered input, secure input, password input, terminal input, interactive input, Python input, character filtering, cursor navigation, string validation, keyboard input, real-time input, typing, text input, data validation, terminal applications

# INPUTX

`inputx` is a Python module that provides an advanced input function with various validation options. It allows you to get user input in a flexible and secure way, supporting data types like `int`, `float`, and `str`, as well as restrictions on the types of characters allowed (e.g., only English letters, digits, symbols, etc.).

## Features

- **Data type validation**: Ensures input is of type `int`, `float`, or `str`.
- **Invisible input**: Can hide user input (useful for passwords).
- **Character restrictions**: Restrict input to specific sets of characters, such as:
  - Only English letters (`a-z`, `A-Z`)
  - Only Russian letters (`а-я`, `А-Я`)
  - Only digits (`0-9`)
  - Only symbols (e.g., `!@#$%^&*`)

## Supported Platforms

Currently, this module supports only **Windows** operating system, because it using `msvcrt` for capturing user input. Other platforms (e.g., Linux, macOS) are not yet supported.


## Installation

To install the package, use [GIT](https://git-scm.com/):

```
git clone https://github.com/KonstantinDigital/Inputx.git
```
Or install directly from [PyPI](https://pypi.org/project/inputx/):

```
pip install inputx

```

## USAGE
### Basic Example
```python
from inputx import inputx

# Get an integer input
age = inputx("Enter your age: ", data_type="int")
print(f"Your age is: {age}")

# Get a float input
price = inputx("Enter the price: ", data_type="float")
print(f"Price: {price}")

# Get a password (invisible input)
password = inputx("Enter your password: ", invisible_input=True)
print("Password entered successfully.")

```

### Restrictions
You can use restrictions to limit the types of characters users can enter.
```python
from inputx import inputx

# Only accept English letters
name = inputx("Enter your name: ", only_en_letters=True)

# Only accept digits and symbols
phone = inputx("Enter your phone number: ", only_digitals=True, only_symbols=True)

# Only accept symbols
symbols = inputx("Enter some symbols: ", only_symbols=True)

```
## License

This project is licensed under the MIT License - see the [LICENSE](https://opensource.org/licenses/MIT) file for details.
symars 0.0.1
Generate Rust code with Sympy, for both scalars and matrices.
License: MIT

# Symars
Generate Rust code from SymPy expressions, including matrices.

# Requirements
```
sympy
sortedcontainers
```

# Use
- `pip install .`
- See `examples.ipynb`.
- Refer to `docs/user_docs.pdf` for details.
- See `rust_generated/src/sym/*.rs` for sample generated code.

# Support

## Supported linear algebra crate 
- `nalgebra`, returns a matrix (including row and column vectors, which share the underlying type `nalgebra::SMatrix`)
- `faer`, passes in a mutable slice of matrix and modifies it.
  - Both `Row`, `Col` and `Mat` are supported.
- Built-in array `[f32; N]` and `[f64; N]` for vector.
- Sparse matrix with its triplet representation stored in `Vec<(usize, usize, value_type)>`.

> If you want to support your own linear algebra crate, refer to `nalgebra.py`.

## Supported data types
`f32`, `f64`

## Supported operations
```rust
+ - * /
powf, sqrt
powi // only for constant integers
sin, cos, tan, cot, asin, acos, atan2
sinh, cosh, tanh, asinh, acosh, atanh
exp, exp2
floor, ceil // behavior of frac is different in rust and sympy.
ln // sp.log(x)
log // sp.log(x, base)
min, max // sp.Min, sp.Max; note to use only for normal numbers (not inf, nan)
signum // sp.sign
abs

```

# Note
1. Some functions are ambiguous (for example, `sign`). Please refer to documentation for their semantics.
2. Please handle NaN and inf carefully by yourself.
3. We don't do indent/format. `cargo fmt` do it for us.
4. Generated function has parameters in lexicographical order of identifiers (default in `sortedcontainers`).
5. If you are using rust-analyzer VSCode extension, try to put your numerical computation code in a crate different from your driver code, especially when the code exceeds say, 10000 lines. Otherwise, your rust-analyzer may hang often.