semvec/pypi-packages huggingface dataset:
ScientificMicroservices 1.0.4
Easily call the APIs by Scientific Microservices. Requires an API key to be registered (currently via RapidAPI)
Requires Python: >=3.9

# Scientific Microservices Python Wrapper

This Python module provides a simple interface to the APIs offered by [Scientific Microservices](https://scientificmicroservices.com/how-it-works). These APIs deliver lightweight, cloud-hosted scientific models designed for rapid data analysis and preprocessing.

## Features

- **Simple Interface** – Invoke scientific models with minimal code.
- **Fast Responses** – Get results in milliseconds.
- **Chainable APIs** – Combine multiple APIs for advanced workflows.
- **Stateless Operations** – Each call is independent.
- **Secure Communication** – All data is transmitted over secure protocols.

## Installation

Install the package using pip:

```bash
pip install ScientificMicroservices
```

## Usage
Here's a basic example of how to use the wrapper:

```python
from ScientificMicroservices import DetectOutliers
# Initialize the API client
api_key = os.environ("api_key")

# Define the input data
input_data = [1, 2, 4, 5, 40, 3, 5, 6]

# Call the API
outliers = DetectOutliers(api_key, input_data)

# Process the response
print(response)

```
Replace DetectOutliers with the specific API you wish to use and adjust the input_data accordingly.

## Documentation

For detailed information on available models and their parameters, please refer to the README on the Rapid product page of the relevant API.

## Contributing

Contributions are welcome! If you'd like to improve this wrapper or add support for additional models, please fork the repository and submit a pull request.

## License
 This project is licensed under the MIT License - see the LICENSE file for details.
starkiller 0.1.3
Import refactoring package and pylsp plugin
Requires Python: >=3.12

# Starkiller

[![PyPI - Version](https://img.shields.io/pypi/v/starkiller)](https://pypi.org/project/starkiller/)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/starkiller)
[![CI status](https://github.com/kompoth/starkiller/actions/workflows/ci.yaml/badge.svg)](https://github.com/kompoth/starkiller/actions)

**Work in progress**

An import refactoring package and [python-lsp-server](https://github.com/python-lsp/python-lsp-server) plugin.
Starkiller aims to be static, i.e. to analyse source code without actually executing it, and fast, thanks to built-in
`ast` module.

The initial goal was to create a simple linter to get rid of star imports, hence the choice of the package name.

## Using as a package

Starkiller can be used as a package for import refactoring. Each public method and class has a docstring explaining
what it does and how to use it.

## Python LSP Server plugin

The `pylsp` plugin provides the following code actions to refactor import statements:

- `Replace * with explicit names` - suggested for `from ... import *` statements. 
- `Replace * import with module import` - suggested for `from ... import *` statements. 
- `Replace from import with module import` - suggested for `from ... import ...` statements.
- `Replace module import with from import` - suggested for `import ...` statements.
- `Remove unnecessary import` - suggested for `import` statements with unused names. 

To enable the plugin install Starkiller in the same virtual environment as `python-lsp-server` with `[pylsp]` optional
dependency. E.g., with `pipx`: 

```bash
pipx inject python-lsp-server starkiller[pylsp]
```

The plugin is enabled just the same way as any other `pylsp` plugin. E.g., in Neovim via
[lspconfig](https://github.com/neovim/nvim-lspconfig):

```lua
require("lspconfig").pylsp.setup {
    settings = {
        pylsp = {
            plugins = {
                starkiller = { enabled = true },
                aliases = {
                    numpy = "np",
                    [ "matplotlib.pyplot" ] = "plt",
                }
            }
        }
    }
}
```

### Comma separated package imports

Multiple package imports like in the following example do not trigger any Code Actions right now:

```python
import os, sys
```

This is hard to understand which import the user wants to fix here: `os`, `sys` or both. Splitting imports to different
lines would help, but the user has to do it manually or with some other tool like [Ruff](https://docs.astral.sh/ruff/).
Starkiller is not a code formatter and should not handle import splitting.

At some point this might change. For example, a separate Code Action for each package could be suggested.

## Alternatives and inspiration

- [removestar](https://www.asmeurer.com/removestar/) is a [Pyflakes](https://github.com/PyCQA/pyflakes) based tool with
similar objectives.
- [SurpriseDog's scripts](https://github.com/SurpriseDog/Star-Wrangler) are a great source of inspiration.
- `pylsp` itself has a built-in `rope_autoimport` plugin utilizing [Rope](https://github.com/python-rope/rope)'s
`autoimport` module.
string-list 0.1.0
Tiny but powerful string <-> list manipulation utilities for Python
Requires Python: >=3.7

# string-list

**Tiny but powerful string <-> list manipulation utilities for Python.**

`string-list` is a lightweight Python package designed to help you quickly and cleanly convert between strings, lists, sets, and more. It’s perfect for handling user input, CSV-style values, or transforming semi-structured data with minimal fuss.

---

## ✨ Features

* ✅ Cleanly split strings into lists (with optional whitespace trimming)
* ✅ Join lists/sets into delimited strings (with optional quoting)
* ✅ Handle unknown input types (`str`, `int`, `list`) and normalize them
* ✅ Case-insensitive set merging with capitalization preference
* ✅ Dictionary enumeration with string keys for config-friendly output

---

## 📦 Installation

```bash
pip install string-list
```

> Then in your Python code:

```python
from string_list import list_from_string
```

---

## 🔧 Usage Examples

### 📌 `list_from_string()`

Split a string into a list with optional trimming:

```python
from string_list import list_from_string

list_from_string("a,b,c")                    # ['a', 'b', 'c']
list_from_string(" a , b , c ", strip=True)  # ['a', 'b', 'c']
list_from_string("1|2|3", delim="|")         # ['1', '2', '3']
```

---

### 📌 `string_from_list()`

Join a list or set into a string:

```python
from string_list import string_from_list

string_from_list(['a', 'b', 'c'])                     # "a,b,c"
string_from_list({'x', 'y'}, quoted=True)             # "'x','y'"
string_from_list([1, 2, 3], delim='|')                # "1|2|3"
string_from_list(['x', None, 'y'])                    # "x,y"
```

---

### 📌 `list_from_any()`

Convert a `str`, `int`, or `list` into a list of strings or integers:

```python
from string_list import list_from_any

list_from_any("10,20,30", return_items_as_int=True)  # [10, 20, 30]
list_from_any(123)                                   # ['123']
list_from_any(['1', '2'])                            # ['1', '2']
```

---

### 📌 `case_insensitive_update()`

Merge two sets while ensuring case-insensitive uniqueness and preferring title-case:

```python
from string_list import case_insensitive_update

base = {"Film", "Movie"}
new = {"film", "Cinema"}
case_insensitive_update(base, new)  # {'Film', 'Movie', 'Cinema'}
```

---

### 📌 `str_enumerate()`

Enumerate any string/list into a dictionary with **string keys** (great for config files or JSON):

```python
from string_list import str_enumerate

str_enumerate("apple,banana", start=1)
# {'1': 'apple', '2': 'banana'}

str_enumerate(["x", "y"])
# {'0': 'x', '1': 'y'}
```

---

## 🧪 Running Tests

If cloning the repo locally:

```bash
pip install -r requirements-dev.txt
pytest tests/
```

---

## 📝 License

MIT Licensed – free to use, share, and modify.

---

## 🙌 Contributing

If you have improvements or new utility functions to add, feel free to open a pull request!