semvec/pypi-packages huggingface dataset:
nomad-media-pip 0.1.10a3
Nomad Media SDK PIP
Requires Python: >=3.12

## Prerequisites

- PIP, Python 3.12

> 📘 Note
> 
> You can download PIP [here](https://pip.pypa.io/en/stable/installation/) and Python 3.12 [here](https://www.python.org/downloads/).

> 📘 Note
> 
> To learn how to update python 3.12 in your terminal, go [here](https://realpython.com/add-python-to-path/#how-to-add-python-to-path-on-windows).

## Setup

- First, open up a terminal and navigate to the directory of the sample you want to run.
- Then install the nomad_media_pip pip.

```shell
pip install nomad_media_pip
```

## Importing Pip

- To import the sdk from the pip, import the class from nomad_media_pip.nomad_sdk.

```python
 from nomad_media_pip.src.nomad_sdk import Nomad_SDK
```

- To initialize the sdk, create the class as shown below.

```python
 nomad_sdk = Nomad_SDK(config)
```

## Logging in

To log in to the sdk, in the config, enter the username/email of your user. Then enter your api key if you are using an api key, or your password.

## Configure Environmental Variables

- The format of the config is:

```python
config = {
    "username": "username",
    "password": "password",
    "apiKey": "apiKey",
    "serviceApiUrl": "serverApiUrl",
    "apiType": "admin",
    "debugMode": "debugMode",
    "singleton": "singleton"
}
```

apiType: Specifies whether the function you are trying to run is **admin** or **portal**.

debugMode: Boolean that specifies when running functions, whether of not to print api call information.

singleton: Whether or not to only create one class instance.

Place the config in a file called config.py and import it into your project.

You are now ready to use the Pip in your project.

> 📘 Make sure to keep your configuration options secret and do not share them publicly.

## Upgrading Pip

- To upgrade the pip, use the following command:

```shell
pip install --upgrade nomad_media_pip
```

## Nomad SDK References

Scroll down to the Nomad SDK section.

[Nomad SDK References](https://developer.nomad-cms.com/reference)

## Nomad SDK PIP Samples

[Nomad SDK PIP Samples](https://github.com/Nomad-Media/samples-python)
yabg_pygments_adapter 0.1.1
Pygments adapter for Yet Another Blog Generator.

# yabg_pygments_adapter

This simple app wraps [Pygments](https://pygments.org/) and [pygments_better_html](https://github.com/Kwpolska/pygments_better_html/) and provides a JSON stdin/stdout interface for them.

This is used by [YetAntotherBlogGenerator (YABG)](https://github.com/Kwpolska/YetAnotherBlogGenerator) to generate code listings.

License: 3-clause BSD.

## Usage

Pipe a JSON list of objects into stdin, receive a JSON list of objects on stdout. The objects look like this:

```python
class Request(typing.TypedDict):
    guid: str
    path: str | None
    language: str | None
    source: str


class Response(typing.TypedDict):
    guid: str
    path: str | None
    success: bool
    html: str
```

The `guid` is used to identify requests and match them up with responses. If `language` is not provided, then `path` will be used to guess it, and if neither is present, Pygments will guess based on the source code.
serialx 0.7.0
Serial library with native async support for Windows and POSIX
Requires Python: >=3.10

# Introduction
Serialx is a no-compromise serial communication library for Python targeting common
platforms such as Linux (POSIX), macOS, and Windows. It provides both synchronous and
native asynchronous APIs for all platforms.

# Installation

```console
pip install serialx
```

# Usage

Serialx features a pyserial and pyserial-asyncio compatibility layer for easy testing.
As early as possible, run `serialx.patch_pyserial()` and it will provide API-compatible
replacements.

```python
import serialx
serialx.patch_pyserial()

# These will now use serialx
import serial
import serial_asyncio
```

Serialx features a familiar synchronous API:

```Python
import serialx

with serialx.Serial("/dev/serial/by-id/port", baudrate=115200) as serial:
    data = serial.readexactly(5)
    serial.write(b"test")

    serial.set_modem_pins(rts=True, dtr=True)
    pins = serial.get_modem_pins()
    assert pins.rts is True
    assert pins.dtr is True
```

A high-level asynchronous serial `(reader, writer)` pair:

```Python
import asyncio
import contextlib

import serialx

async def main():
	reader, writer = await serialx.open_serial_connection("/dev/serial/by-id/port", baudrate=115200)

	with contextlib.closing(writer):
	    data = await reader.readexactly(5)
	    writer.write(b"test")
	    await writer.drain()
```

And a low-level asynchronous serial transport:

```Python
import asyncio
import serialx

async def main():
	loop = asyncio.get_running_loop()
	protocol = YourProtocol()

	transport, protocol = await serialx.create_serial_connection(
	    loop,
	    lambda: protocol,
	    url="/dev/serial/by-id/port",
	    baudrate=115200
	)

	await transport.set_modem_pins(rts=True, dtr=True)
```

# Development
All development dependencies are listed in `pyproject.toml`. To install them, use:
```bash
uv pip install '.[dev]'
```

On macOS and Windows, a Rust toolchain is required to build the native serial port
enumeration extension. Install Rust via [rustup](https://rustup.rs/).

Set up pre-commit hooks with `pre-commit install`. Your code will then be type checked
and auto-formatted when you run `git commit`. You can do this on-demand with
`pre-commit run`.

Serialx relies on automated testing. We do not have a custom GitHub Actions runners with
real hardware (yet) so GitHub Actions CI will only run `socat` tests.

To run tests locally with loopback adapters and pairs of real adapters, pass CLI flags
to `pytest`:

```bash
pytest --loopback-adapter=/dev/serial/by-id/my-loopback-adapter \
       --adapter-pair=/dev/serial/by-id/left1:/dev/serial/by-id/right1 \
       --adapter-pair=/dev/serial/by-id/left2:/dev/serial/by-id/right2
```

By default, this will run tests in parallel across all adapter pairs. You can disable
this by passing `-n 0` to `pytest`, which will execute the tests sequentially.
picobuild 0.1.0
Building tools for CPython extensions
Requires Python: >=3.13

# picobuild

Building tools for CPython extensions (Cython, setuptools) and standalone executables.

## Install

```bash
pip install picobuild
```

Or with uv:

```bash
uv add picobuild
```

## Quick start

### setuptools + Cython

Re-export of setuptools’ `Extension`, `find_packages`, and `setup`, plus a Cython build dir that stays out of the way of the main build:

```python
from Cython.Build import cythonize  # or use picobuild.cythonize
from picobuild import Extension, get_cython_build_dir, setup

extensions = cythonize(
    [Extension("mypkg.foo", ["src/mypkg/foo.pyx"])],
    build_dir=get_cython_build_dir(),
)
setup(ext_modules=extensions, ...)
```

Or use picobuild’s `cythonize`, which sets the build dir for you:

```python
from picobuild import Extension, cythonize, setup

extensions = cythonize([Extension("mypkg.foo", ["src/mypkg/foo.pyx"])])
setup(ext_modules=extensions, ...)
```

### Standalone executable from Python

Build a single-file executable from a Python script (Cython --embed + gcc):

```python
from picobuild import build_cython_executable

build_cython_executable("hello.py", "bin/hello")
```

Or with parameters:

```python
from picobuild import ExecutableParameters, build_cython_executable

params = ExecutableParameters("script.py", build_dir="bin", executable_name="myapp")
build_cython_executable(params._source_file, params._executable_file)
```

## API

| Name | Description |
|------|-------------|
| `Extension` | setuptools `Extension` (for Cython/C extensions). |
| `find_packages` | setuptools `find_packages`. |
| `setup` | setuptools `setup`. |
| `get_cython_build_dir(build_dir="build")` | Path like `build/cython.linux-x86_64-cpython-313` for Cython output. |
| `cythonize(*args, **kwargs)` | Cython’s `cythonize` with `build_dir` set via `get_cython_build_dir`. |
| `build_cython_executable(source_file, dest_file=None)` | Build a standalone executable from a `.py` file. |
| `ExecutableParameters(source_file, build_dir, executable_name=None)` | Parameters for the executable build. |

## Docs

Full API and usage: [Sphinx documentation](https://picops.github.io/picobuild/) (or build locally with `make docs`).

## Development

```bash
make sync        # uv sync --extra dev
make install-uv  # sync + editable install
make test        # unittest
make check       # isort, black, flake8, mypy
make docs       # Sphinx HTML in docs/_build/html
```

## License

BSD-3-Clause.
select-ai 1.3.0rc1
Select AI for Python
Requires Python: >=3.9
Keywords: oracle, select-ai, adbs, autonomous database serverless

# Select AI for Python


Select AI for Python enables you to ask questions of your database data using natural language (text-to-SQL), get generative AI responses using your trusted content (retrieval augmented generation), generate synthetic data using large language models, and other features – all from Python. With the general availability of Select AI Python, Python developers have access to the functionality of Select AI on Oracle Autonomous Database.

Select AI for Python enables you to leverage the broader Python ecosystem in combination with generative AI and database functionality - bridging the gap between the DBMS_CLOUD_AI PL/SQL package and Python's rich ecosystem. It provides intuitive objects and methods for AI model interaction.


## Installation

Run
```bash
python3 -m pip install select_ai
```

## Documentation

See [Select AI for Python documentation][documentation]

## Samples

Examples can be found in the [/samples][samples] directory

### Basic Example

```python
import select_ai

user = "<your_select_ai_user>"
password = "<your_select_ai_password>"
dsn = "<your_select_ai_db_connect_string>"

select_ai.connect(user=user, password=password, dsn=dsn)
profile = select_ai.Profile(profile_name="oci_ai_profile")
# run_sql returns a pandas dataframe
df = profile.run_sql(prompt="How many promotions?")
print(df.columns)
print(df)
```

### Async Example

```python

import asyncio

import select_ai

user = "<your_select_ai_user>"
password = "<your_select_ai_password>"
dsn = "<your_select_ai_db_connect_string>"

# This example shows how to asynchronously run sql
async def main():
    await select_ai.async_connect(user=user, password=password, dsn=dsn)
    async_profile = await select_ai.AsyncProfile(
        profile_name="async_oci_ai_profile",
    )
    # run_sql returns a pandas df
    df = await async_profile.run_sql("How many promotions?")
    print(df)

asyncio.run(main())

```
## Help

Questions can be asked in [GitHub Discussions][ghdiscussions].

Problem reports can be raised in [GitHub Issues][ghissues].

## Contributing

This project welcomes contributions from the community. Before submitting a pull request, please [review our contribution guide][contributing]

## Security

Please consult the [security guide][security] for our responsible security vulnerability disclosure process

## License

Copyright (c) 2025 Oracle and/or its affiliates.

Released under the Universal Permissive License v1.0 as shown at
<https://oss.oracle.com/licenses/upl/>.

[contributing]: https://github.com/oracle/python-select-ai/blob/main/CONTRIBUTING.md
[documentation]: https://oracle.github.io/python-select-ai/
[ghdiscussions]: https://github.com/oracle/python-select-ai/discussions
[ghissues]: https://github.com/oracle/python-select-ai/issues
[samples]: https://github.com/oracle/python-select-ai/tree/main/samples
[security]: https://github.com/oracle/python-select-ai/blob/main/SECURITY.md