semvec/pypi-packages huggingface dataset:
thinking-machine 0.0.4
Thinking machine is a machine that thinks.
Requires Python: >=3.10
Keywords: package-name

# Thinking Machine
Thinking Machine is a machine that thinks.
<pre>
  pip install thinking-machine
</pre>
Then:
```Python
  # Python
  import thinking_machine
```
Or:
<pre>
  uvx thinking-machine [ARGUMENT] [OPTION]
</pre>
cpp-linter 1.12.0
Run clang-format and clang-tidy on a batch of files.
Requires Python: >=3.9
Keywords: clang, clang-tools, linter, clang-tidy, clang-format

C/C++ Linting Package
=====================

.. |latest-version| image:: https://img.shields.io/github/v/release/cpp-linter/cpp-linter
    :alt: Latest Version
    :target: https://github.com/cpp-linter/cpp-linter/releases
.. |python-version| image:: https://img.shields.io/pypi/pyversions/cpp-linter
    :alt: Python Version
    :target: https://pypi.org/project/cpp-linter
.. |license-badge| image:: https://img.shields.io/github/license/cpp-linter/cpp-linter?label=license&logo=github
    :alt: License
    :target: https://github.com/cpp-linter/cpp-linter/blob/main/LICENSE
.. |codecov-badge| image:: https://codecov.io/gh/cpp-linter/cpp-linter/branch/main/graph/badge.svg?token=0814O9WHQU
    :alt: CodeCov
    :target: https://codecov.io/gh/cpp-linter/cpp-linter
.. |doc-badge| image:: https://github.com/cpp-linter/cpp-linter/actions/workflows/docs.yml/badge.svg
    :alt: Docs
    :target: https://cpp-linter.github.io/cpp-linter
.. |pypi-badge| image:: https://img.shields.io/pypi/dw/cpp-linter?color=dark-green&label=PyPI%20Downloads&logo=python&logoColor=white
    :target: https://pepy.tech/project/cpp-linter
    :alt: PyPI - Downloads

|latest-version| |python-version| |license-badge| |codecov-badge| |doc-badge| |pypi-badge|

A Python package for linting C/C++ code with clang-tidy and/or clang-format to collect feedback provided in the form of thread comments and/or file annotations.

Usage
-----

For usage in a CI workflow, see `the cpp-linter/cpp-linter-action repository <https://github.com/cpp-linter/cpp-linter-action>`_

For the description of supported Command Line Interface options, see `the CLI documentation <https://cpp-linter.github.io/cpp-linter/cli_args.html>`_

Have question or feedback?
--------------------------

To provide feedback (requesting a feature or reporting a bug) please post to `issues <https://github.com/cpp-linter/cpp-linter/issues>`_.

License
-------

The scripts and documentation in this project are released under the `MIT License <https://github.com/cpp-linter/cpp-linter/blob/master/LICENSE>`_.
foxglove-sdk 0.17.2
Foxglove Python SDK
Requires Python: >=3.10

# Foxglove Python SDK

The official [Foxglove](https://docs.foxglove.dev/docs) SDK for Python.

This package provides support for integrating with the Foxglove platform. It can be used to log
events to local [MCAP](https://mcap.dev/) files or a local visualization server that communicates
with the Foxglove app.

## Get Started

See https://foxglove.github.io/foxglove-sdk/python/

## Requirements

- Python 3.10+

## Examples

We're using uv as a Python package manager in the foxglove-sdk-examples.

To test that all examples run (as the CI does) you can use `yarn run-python-sdk-examples` in the repo root.

To run a specific example (e.g. write-mcap-file) with local changes:

```
cd python/foxglove-sdk-examples/write-mcap-file
uv run --with ../../foxglove-sdk main.py [args]
```

Keep in mind that uv does two layers of caching.
There's the .venv in your project directory, plus a global cache at ~/.cache/uv.

uv tries to be smart about not rebuilding things it has already built,
which means that if you make changes and you want them to show up,
you also need to run `uv cache clean`.
openinference-instrumentation-smolagents 0.1.22
OpenInference smolagents Instrumentation
Requires Python: <3.15,>=3.10

# OpenInference smolagents Instrumentation

[![pypi](https://badge.fury.io/py/openinference-instrumentation-smolagents.svg)](https://pypi.org/project/openinference-instrumentation-smolagents/)

Python auto-instrumentation library for LLM agents implemented with smolagents

Crews are fully OpenTelemetry-compatible and can be sent to an OpenTelemetry collector for monitoring, such as [`arize-phoenix`](https://github.com/Arize-ai/phoenix).

## Installation

```shell
pip install openinference-instrumentation-smolagents
```

## Quickstart

This quickstart shows you how to instrument your LLM agent application.

You've already installed openinference-instrumentation-smolagents. Next is to install packages for smolagents,
Phoenix and `opentelemetry-instrument`, which exports traces to it.

```shell
pip install smolagents arize-phoenix opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc opentelemetry-distro
```

Start Phoenix in the background as a collector, which listens on `http://localhost:6006` and default gRPC port 4317.
Note that Phoenix does not send data over the internet. It only operates locally on your machine.

```shell
python -m phoenix.server.main serve
```

Create an example like this:

```python
from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel

agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())

agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")
```

Then, run it like this:

```shell
opentelemetry-instrument python example.py
```

Finally, browse for your trace in Phoenix at `http://localhost:6006`!

## Manual instrumentation

`opentelemetry-instrument` is the [Zero-code instrumentation](https://opentelemetry.io/docs/zero-code/python) approach
for Python. It avoids explicitly importing and configuring OpenTelemetry code in your main source. Alternatively, you
can copy-paste the following into your main source and run it without `opentelemetry-instrument`.

```python
from opentelemetry.sdk.trace import TracerProvider

from openinference.instrumentation.smolagents import SmolagentsInstrumentor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
trace_provider = TracerProvider()
trace_provider.add_span_processor(SimpleSpanProcessor(otlp_exporter))

SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
```

## More Info

* [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
* [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
* [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)
openinference-instrumentation-vertexai 0.1.12
OpenInference VertexAI Instrumentation
Requires Python: <3.14,>=3.9

# OpenInference Google VertexAI Instrumentation

Python auto-instrumentation library for VertexAI SDK and the Google Cloud AI Platform. Traces are fully OpenTelemetry compatible and can be sent to any OpenTelemetry collector for viewing, such as [Arize Phoenix](https://github.com/Arize-ai/phoenix).

[![pypi](https://badge.fury.io/py/openinference-instrumentation-vertexai.svg)](https://pypi.org/project/openinference-instrumentation-vertexai/)

## Installation

```shell
pip install -Uqqq openinference-instrumentation-vertexai
```

## Quickstart

Install `openinference-instrumentation-vertexai` and `arize-phoenix`.


```shell
pip install -U \
    openinference-instrumentation-vertexai \
    arize-phoenix \
    opentelemetry-sdk \
    opentelemetry-exporter-otlp \
    "opentelemetry-proto>=1.12.0"
```

Start the `phoenix` server so that it is ready to receive traces.
The `phoenix` server runs entirely on your machine and does not send data over the internet.

```shell
python -m phoenix.server.main serve
```

Instrumenting `vertexai` is simple.

```python
from openinference.instrumentation.vertexai import VertexAIInstrumentor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

endpoint = "http://127.0.0.1:4317"
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))

VertexAIInstrumentor().instrument(tracer_provider=tracer_provider)
```

Now, all calls by `generative_models` are instrumented and can be viewed in the `phoenix` UI.

```python
import vertexai
from vertexai.generative_models import GenerativeModel

vertexai.init(location="us-central1")
model = GenerativeModel("gemini-1.5-flash")

print(model.generate_content("Why is sky blue?"))
```

## More Info

* [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
* [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
* [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)
phlower-tensor 0.1.2
A PyTorch tensor extension for physical dimension-aware tensors.
Requires Python: >=3.11

## phlower_tensor


### Description

This library is separated from [the main phlower library](https://github.com/ricosjp/phlower) to provide tensor operations and utilities that can be used independently. It includes tensor objects which have physical dimensions, as well as various tensor operations such as addition, multiplication, contraction, and more.



### Installation

You can install the library using pip:

```bash
pip install phlower-tensor
```


### Usage

Here is a simple example of how to use the phlower_tensor library:

```python
import torch
from phlower_tensor import phlower_tensor

# Create two tensors with physical dimensions
velocity = phlower_tensor(torch.rand(100, 3), dimension={"T": -1, "L": 1})
mass = phlower_tensor(torch.rand(100, 1), dimension={"M": 1})

kinetic_energy = 0.5 * mass * (velocity ** 2)
print(kinetic_energy.dimension)
# Output: PhlowerDimensionTensor(T: -2.0, L: 2.0, M: 1.0, I: 0.0, Theta: 0.0, N: 0.0, J: 0.0)

```


Physical dimensions are represented as dictionaries where keys are dimension symbols (e.g., "L" for length, "T" for time) and values are their respective exponents.

| Symbol | Dimension      |
|--------|----------------|
| L      | Length         |
| T      | Time           |
| M      | Mass           |
| I      | Electric Current |
| Theta  | Temperature    |
| N      | Amount of Substance |
| J      | Luminous Intensity |


### License

This project is licensed under the Apache-2.0 License. See the [LICENSE](LICENSE) file for details.