semvec/pypi-packages huggingface dataset:
pdusms 1.0
PDU Converter: SMS PDU encoding and decoding, including GSM-0338 character set, support Python 3
Requires Python: >=3.6

# PDU Converter Package

## About this Package
* This library will help you to encode and decode raw SMS data
* Support 7-bit, 8-bit, 16-bit
* Requires Python 3.6 or better

## How to use (Encode and Decode)
Example to number `0123456789` with message `Chào thế giới`
```
>>> import smspdu, time
>>> p = smspdu.SMS_DELIVER.create('0123456789', '987654321', 'Chào thế giới', datestamp=time.time(), tp_sri=1, tp_mms=0)
>>> print(p.toPDU())
200A8110325476980008122182514023001A0043006800E0006F0020007400681EBF0020006700691EDB0069
>>> s = smspdu.SMS_DELIVER.fromPDU(p.toPDU(), '0123456789')
>>> print("s.tp_address: " + s.tp_address)
>>> print("s.tp_scts: " + s.tp_scts)
>>> print("s.user_data: " + s.user_data)
s.tp_address: 0123456789
s.tp_scts: 21122815043200
s.user_data: Chào thế giới
```

This is upgrade version. The original from [smspdu 1.0](https://pypi.org/project/smspdu/)
stift 0.3.0
A package to implement spreadsheet-style functions in a safe way
Requires Python: >=3.8

# stift

An awesome module for executing "safe" functions from strings.

## Parser Module

Parse a string with functions, strings, variables, and arrays. This allows an executor to
construct the response of the string execution.

A tool to use these arguments should start at the end of the returned array (lowest level)
and work upwards. Anything of type "str", "int", or "float" can be used as-is. Anything
with type ParseTypes.array, ParseTypes.function, or ParseTypes.variable need to be processed.

```python
:param s: String to be parsed
:type s: str
:raises ParserError: Issue with parsing somewhere along the line
:return: Returns a nested list of "Token" dictionaries. These always include a value and a type.
For functions, there will also be an argc and argv element (see example)
For arrays, there will also be an index element (See example)
{
    type: ParseTypes.function, # Type can be str, int, float, or a ParseTypes element
    value: "ceiling" # Variable value or function/array name
    argc: 2, # (Functions only) number of arguments
    argv: [(1,2), (1,3)], # (Functions only) pointer to arg locations e.g. parsed[1][2]
}

:rtype: List[List[dict]]
```

### Parser Example

```python
from stift.parser import Parser, ParserError, ParseTypes

s = r"""blend(banana, kiwi(1,2,"\"yes\" or \"no\"", mango[0]))"""
parsed = Parser().parse(s)

# Returns the following:
# [
#     [
#         {
#             "type": ParseTypes.function,
#             "value": "b",
#             "argc": 2,
#             "argv": [(1, 0), (1, 1)],
#         }
#     ],
#     [
#         {"type": str, "value": "a"},
#         {"type": ParseTypes.array, "value": "s", "index": (2, 0)},
#     ],
#     [{"type": int, "value": 0}],
# ]
```

## Functions (WIP)