semvec/pypi-packages huggingface dataset:
gerstlix_python 1.0
Library for simplified access to the Gerstlix API
Requires Python: <4.0,>=3.9

# pip install gerstlix_python

## What is this? ##
Library for simplified access to the Gerstlix API

## Quick Guide ##
To access the methods of the module, you need to:
```py
from gerstlix_python import *
gx = gerstlixAPI(token="your_token")
```

## Example ##
```py
from gerstlix_python import *
gx = gerstlixAPI(token="your_token")

result = gx.get_members(server=3, fractionId=1)
print(result)
```
### Output ###
```json
{
    "serverId": 1, 
    "serverName": "serverName", 
    "fractionId": 1, 
    "fractionName": "fractionName", 
    "playersLastUpdate": "2023-10-13 13:03:40", 
    "playersCount": 1, 
    "playersInfo": [
        {
            "nickname": "nickname", 
            "accountId": 1, 
            "rang": 1, 
            "rankLabel": "rankLabel", 
            "isLeader": true, 
            "isOnline": false, 
            "gameId": -1, 
            "level": -1
        }
    ]
}
```

## Currently available methods ##
```
.get_leader             : params = server, fractionId
.get_deputy             : params = server, fractionId
.get_members            : params = server, fractionId
.get_minister           : params = server, fractionId
.get_record_fraction    : params = server, fractionId
.get_player             : params = server, player     
.get_status             : params = gameProject       
.get_info               : params = server             
.get_ghetto_territories : params = server            
.get_old_players        : params = server            
.get_rich_players       : params = server            
.get_deputies           : params = server            
.get_leaders            : params = server            
.get_minister_list      : params = server            
.get_records            : params = server            
.get_admins_list        : params = server            
.check_work_methods     : params = None              
.count_methods          : params = None              
.get_ip                 : params = ip                
```
## Types of parameters ##
```
server       : INTEGER
fractionId   : INTEGER
gameProject  : STRING [ arz, marz, rrp ]
ip           : IPv4
----------------------------------------
arz          : Arizona Role Play
marz         : Mobile Arizona Role Play
rrp          : Rodina Role Play
```

## Other information ##
[Gerstlix site](https://gerstlix.com/)
The module is specially designed for Gerstlix
data-transformation-yfhsi 0.18.1a0
Data Transfomation Libraries. Transpose. Time Series Windowing. Cross Correlation
Requires Python: <4.0,>=3.11

The Data Transformation Libraries package **data_transformation_yfhsi** contains one module:<br>
**data_transformation**<br>


The **data_transformation** module contains three functions:<br>

**transpose2d**<br>
The "transpose2d" function switches the axes of a 2D tensor.<br>
The transpose function has a signature: **transpose2d(input_matrix: list[list[float]]) -> list**<br>
Parameters:<br>
    input_matrix (list[list[float]]): The input 2D matrix to be transposed.<br>
Returns:<br>
    list: The transposed 2D matrix.<br>

How to use an example:
```
from data_transformation_yfhsi import data_transformation

input_matrix = [[1.0, 2.0, -3.0, 4.0], [4.0, 5.0, 6.3, 7.0], [7.0, 8.0, 9.0, 10.0], [11.0, 12.0, 13.0, 14.0]]
data_transformation.transpose2d(input_matrix)
```
Returns:
```
[[1.0, 4.0, 7.0, 11.0], [2.0, 5.0, 8.0, 12.0], [-3.0, 6.3, 9.0, 13.0], [4.0, 7.0, 10.0, 14.0]]
```

**window1d**<br>
The "window1d" function is used for time series windowing.<br>
The time series windowing function has a signature: **window1d(input_array: list | np.ndarray, size: int, shift: int = 1, stride: int = 1) -> list[list | np.ndarray]**<br>
Parameters:<br>
    input_array (list | np.ndarray): The input 1D array or numpy array.<br>
    size (int): The size of the sliding window.<br>
    shift (int): The amount to shift the window by for each step. Default is 1.<br>
    stride (int): The stride of the window. Default is 1.<br>
Returns:<br>
    list[list | np.ndarray]: A list of windows, each containing elements from the input array.<br>

How to use an example:
```
from data_transformation_yfhsi import data_transformation

input_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10.0, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
data_transformation.window1d(input_array, 4)
```
Returns:
```
[[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9], [7, 8, 9, 10.0], [8, 9, 10.0, 11], [9, 10.0, 11, 12], [10.0, 11, 12, 13], [11, 12, 13, 14], [12, 13, 14, 15], [13, 14, 15, 16], [14, 15, 16, 17], [15, 16, 17, 18], [16, 17, 18, 19], [17, 18, 19, 20]]
```

**convolution2d**<br>
The "convolution2d" function performs cross-correlation.<br>
The cross correlation function has a signature: **convolution2d(input_matrix: np.ndarray, kernel: np.ndarray, stride : int = 1) -> np.ndarray**<br>
Parameters:<br>
    input_matrix (np.ndarray): The input 2D matrix.<br>
    kernel (np.ndarray): The 2D convolution kernel.<br>
    stride (int): The stride of the convolution operation. Default is 1.<br>
Returns:<br>
    np.ndarray: The result of the 2D convolution operation.<br>

How to use an example:
```
from data_transformation_yfhsi import data_transformation

input_matrix = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
kernel = np.array([[0, 1], [2, 3]])
data_transformation.convolution2d(input_matrix, kernel)
```
Returns:
```
[[19. 25.], [37. 43.]]<br>
```
pylacc 0.0.3
Python Linear Analog Circuit Caclulator
Requires Python: >=3.4

# PyLACC

Python Linear Analog Circuit Caclulator

## API

`from pylacc.circuit import *`

### Components

- Voltage Source:
    - `E(E, F, **)`
- Current Source:
    - `I(I, F, **)`
- Resistor:
    - `R(R, F, **)`
- Capacitor:
    - `C(C, **)`
    - `XC(XC, **)`
- Inductor:
    - `L(L, **)`
    - `XL(XL, **)`
- `**`
    - `E` Voltage (complex, phasor)
    - `I` Current (complex, phasor)
    - `Z` Impedence (complex, phasor) (alias `R`)
    - `C` Capacitance (positive, real)
    - `L` Inductance (positive, real)
    - `XC` Capacitive Reactance (positive, real)
    - `XL` Inductive Reactance (positive, real)
    - `F` Frequency (positive, real)
    - `PT` True Power (positive, real) (alias `P`)
    - `PR` Reactive Power (positive, real)
    - `PA` Apparent Power (positive, real)

- All names can be lower case for fast calculator input
- All arguments are optional

#### Complex Values

- `1.0 + 1.0j` (complex)
- `(radius, angle)` (phasor, degrees)

## Units

- `k` 10^3
- `M` 10^6
- `G` 10^9
- `T` 10^12
- `m` 10^-3
- `u` 10^-6
- `n` 10^-9
- `p` 10^-12

## Series Circuits `+`

`e(12) + r(100) + r(300)`

```
+(12V 30mA)
+-S[12V](30mA 360mW)
+-R[100Ω](3V 30mA)
+-R[300Ω](9V 30mA)
```

## Parallel Circuits `/`

`e(12, 60) + xl(100) / xc(200) / r(300)`

```
+(12V 72.1∠-56.3°mA)
+-S[12V 60Hz](72.1∠-56.3°mA 865mVA)
+-/(12V 72.1∠-56.3°mA)
+ /-L[100Ω](12V 120∠-90°mA 265mH)
+ /-C[200Ω](12V 60∠90°mA 13.3μF)
+ /-R[300Ω](12V 40mA)
```

## Solving

`.solve()` recursively solves for all unknowns. Printing or representing a component / circuit implicitly triggers the solver.

## Filtering

- `_.z` - Only show inferred impedence
- `_.p` - Only show inferred power
- `_('e', 'z')` - Custom output filter
- `_('e,z')` - Calculator shorthand

## Grouping

Components can be grouped to prevent further concatenation.

```
FILTER = (l(1e-3) + c(0.0022e-6)).g
C = e(10, 107e3) + FILTER + r(100)
C.solve()
FILTER
```

```
+(380∠-87.8°mV 99.9∠2.18°mA)
+-L[1mH](67.2∠92.2°V 99.9∠2.18°mA 672Ω)
+-C[2.2nF](67.6∠-87.8°V 99.9∠2.18°mA 676Ω)
```

## TODO

- Support multiple sources