semvec/pypi-packages huggingface dataset:
search-engine-pkg 0.1.0
A unified wrapper for search engines like Serper, DuckDuckGo, etc.
Requires Python: >=3.9

# Search Engine Client

Lightweight, async wrappers around multiple search engine APIs (Serper/Google, DuckDuckGo, Bing). This package provides a small, opinionated interface for running text and image searches and returning standardized results.

## Features

- Async-first search engine clients implementing a common `BaseSearchEngine` interface.
- Built-in engines: Serper (Google), DuckDuckGo, Bing (concrete implementations in `src/search_wrapper/engines`).
- Concurrent text + image fetching for engines that support both.

## Installation

Install for development (editable) and add required dependencies:

```bash
pip install -e .
pip install httpx
```

## Quick start

Set the required API key for services that need one (example for Serper/Google):

```powershell
$env:GOOGLE_SERPER_API_KEY = "your_api_key_here"
```

Example usage (async):

```python
import asyncio
from search_wrapper import GoogleSearchFromSerper

async def main():
	async with GoogleSearchFromSerper(api_key="YOUR_KEY") as client:
		results = await client.search("python async http client")
		print(results)

asyncio.run(main())
```

Alternatively import specific engine directly:

```python
from search_wrapper.engines.serper import GoogleSearchFromSerper
```

## Development notes

- Source layout lives under `src/` (package name: `search_wrapper`). Either install the package in editable mode (`pip install -e .`) or add `src` to `PYTHONPATH`/VS Code `python.analysis.extraPaths` so imports resolve in the editor.
- The Serper client uses `httpx.AsyncClient` — ensure `httpx` is installed in your active environment.
- Tests and examples live at the project root (`test_search.py`, `main.py`).

## Contributing

Feel free to open issues or PRs. When adding new engines, implement `BaseSearchEngine` and expose the engine in `src/search_wrapper/__init__.py`.

---
codex-python 1.0.1
Python SDK for Codex CLI with bundled platform binaries
Requires Python: >=3.12
Keywords: codex, sdk, cli, automation

# codex-python

Python SDK for Codex with bundled `codex` binaries inside platform wheels.

The SDK mirrors the TypeScript SDK behavior:
- Spawns `codex exec --experimental-json`
- Streams JSONL events
- Supports thread resume, structured output schemas, images, sandbox/model options

## Install

```bash
pip install codex-python
```

## Quickstart

```python
from codex import Codex

client = Codex()
thread = client.start_thread()

result = thread.run("Diagnose the failing tests and propose a fix")
print(result.final_response)
print(result.items)
```

## Streaming

```python
from codex import Codex

client = Codex()
thread = client.start_thread()

stream = thread.run_streamed("Investigate this bug")
for event in stream.events:
    if event["type"] == "item.completed":
        print(event["item"])
    elif event["type"] == "turn.completed":
        print(event["usage"])
```

## Structured output

```python
from codex import Codex, TurnOptions

schema = {
    "type": "object",
    "properties": {"summary": {"type": "string"}},
    "required": ["summary"],
    "additionalProperties": False,
}

client = Codex()
thread = client.start_thread()
result = thread.run("Summarize repository status", TurnOptions(output_schema=schema))
print(result.final_response)
```

## Input with local images

```python
from codex import Codex

client = Codex()
thread = client.start_thread()
result = thread.run(
    [
        {"type": "text", "text": "Describe these screenshots"},
        {"type": "local_image", "path": "./ui.png"},
        {"type": "local_image", "path": "./diagram.jpg"},
    ]
)
```

## Resume a thread

```python
from codex import Codex

client = Codex()
thread = client.resume_thread("thread_123")
thread.run("Continue from previous context")
```

## Options

- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`, `config`, `env`
- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`, `model_reasoning_effort`, `network_access_enabled`, `web_search_mode`, `web_search_enabled`, `approval_policy`, `additional_directories`
- `TurnOptions`: `output_schema`, `signal`

## Cancellation

```python
import threading

from codex import Codex, TurnOptions

cancel = threading.Event()

client = Codex()
thread = client.start_thread()
stream = thread.run_streamed("Long running task", TurnOptions(signal=cancel))

cancel.set()
for event in stream.events:
    print(event)
```

## Bundled binary behavior

By default, the SDK resolves the bundled binary at:

`codex/vendor/<target-triple>/codex/{codex|codex.exe}`

If the bundled binary is not present (for example in a source checkout), the SDK falls back to
`codex` on `PATH`.

You can always override with `CodexOptions(codex_path_override=...)`.

## Development

```bash
make lint
make test
```

If you want to test vendored-binary behavior locally, fetch binaries into `codex/vendor`:

```bash
python scripts/fetch_codex_binary.py --target-triple x86_64-unknown-linux-musl
```
tt-update-tensix-disable-count 0.0.2
Update Tensix column disable count in firmware bundle
Requires Python: >=3.9

# Tenstorrent Tensix Harvesting Tool

This tool is intended to support editing the count of disabled Tensix
columns within a firmware bundle for Tenstorrent Blackhole cards. The primary
use case for this tool is enabling Tensix cores that have been "soft harvested"
on p150 cards. p150 cards (purchased prior to Jan 2026) contain 20 additional
Tensix cores, which can be reenabled with this tool. Note that metal and other
Tenstorrent software will not optimize for these cores moving forward.

The Tensix column count is set by specification tables in the firmware bundle,
which this tool is capable of editing. A modified firmware bundle can then be
flashed to the Blackhole card in order to enable additional Tensix columns.

## Requirements

This tool requires `protoc` be installed and available on your path. On Ubuntu,
this can be installed with the command `sudo apt install protobuf-compiler`

## Usage

In order to modify the Tensix disable count for all Blackhole p150 cards, run
the following. Please use tt-flash >= 3.6.0 to avoid known issues with
overwriting board configuration data:

```
pip install tt-update-tensix-disable-count
tt-update-tensix-disable-count \
	--input <input_fwbundle> \
	--output <output_fwbundle>  \
	--board P150A-1 --board P150B-1 --board P150C-1 \
	--disable-count 0
pip install tt-flash>=3.6.0
tt-flash <output_fwbundle>
# Verify number of Tensix cores available
python3 -c "import pyluwen; print(pyluwen.detect_chips()[0].get_telemetry().tensix_enabled_col.bit_count() * 10)"
```


## Support

While Tenstorrent will continue to support this tool, Metal and other
Tenstorrent software will not optimize for the additional 20 Tensix
cores on early p150 cards going forwards.
refl1d 1.0.1b0
Neutron and X-ray reflectometry analysis
Requires Python: >=3.10

Refl1D
======

Refl1D is a program for analyzing 1-D reflectometry measurements made with
X-ray and neutron beamlines.  The 1-D models give the depth profile for
material scattering density composed of a mixture of flat and continuously
varying freeform layers. With polarized neutron measurements, scientists
can study the sub-surface structure of magnetic samples. The architecture
supports the addition of specialized layer types such as models for the
density distribution of polymer brushes, and volume space modeling for
proteins in bio-membranes. We provide a number of these models as well as
supporting user defined layer types for both structural and magnetic
scattering densities.

Fitting is provided by Bumps, a bayesian uncertainty analysis program.  In
addition to the usual uncertain estimated from the covariance at the best
fit location, Bumps includes a Markov chain Monte Carlo analysis code which
more completely describes the uncertain and correlations between parameters.
Fitting is done in parallel, either using python multiprocessing on a
multicore machine, or using MPI for running on a cluster.

Documentation is available at `<https://refl1d.readthedocs.io>`_. See
`CHANGES.rst <https://github.com/reflectometry/refl1d/blob/master/CHANGES.rst>`_
for details on recent changes. Information on the refl1d release process is in `release notes <release.md>`_.

Use ``pip install refl1d`` to install in your python environment.

For the windows application, follow the installation instructions on the
`latest release <https://github.com/reflectometry/refl1d/releases/latest>`_
page.  (For the latest bleeding-edge build, see the 
`unstable release <https://github.com/reflectometry/refl1d/releases/tag/sid>`_)

Submit requests and pull requests to the project
`git pages <https://github.com/reflectometry/refl1d>`_

|CI| |RTD| |DOI|

.. |CI| image:: https://github.com/reflectometry/refl1d/actions/workflows/test.yml/badge.svg
   :alt: Build status
   :target: https://github.com/reflectometry/refl1d/actions

.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.1249715.svg
   :alt: DOI tag
   :target: https://zenodo.org/doi/10.5281/zenodo.1249715

.. |RTD| image:: https://readthedocs.org/projects/refl1d/badge/?version=latest
   :alt: Documentation status
   :target: https://refl1d.readthedocs.io/en/latest
cli-for-tools 0.3.1
Cli for traps team tools
Requires Python: >=3.9

<a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>
# Cli Guadalupe Data


![demo](https://github.com/IslasGECI/kanban/assets/53709062/faed1c14-9a41-4125-8140-fa58c3910cd2)

## `paco_el_chato`
Paco el chato es el asistente para las tareas de gabinete en el proyecto de erradicación de gato
feral en Isla Guadalupe.

Tiene tres habilidades:
- clasificar fotos con gatos
- generar un esbozo del mapa con trampas activas y desactivas de Isla Guadalupe
- actualizar la paquetería para hacer las tareas anteriores

## Instalación 🏗️
Podemos instalar esta aplicación usando `pip`:
```shell
pip uninstall cli-for-tools
pip install cli-for-tools
```

## Modo de uso
Para utilizar `haz-mapa` o `clasifica-fotos` debemos abrir la terminal desde la carpeta de trabajo:
1. damos doble _click_ a la carpeta de trabajo
1. damos _click_ derecho al ratón y escogemos la opción **Open Terminal**
1. escribimos el comando `paco_el_chato --help` y tendremos la ayuda general
1. escribimos el comando `paco_el_chato haz-mapa --help` y tendremos la ayuda del comando `haz-mapa`
1. escribimos el comando `paco_el_chato clasifica-fotos --help` y tendremos la ayuda del comando `clasifica-fotos`

## `haz-mapa`
Hace un esbozo del mapa de Isla Guadalupe con las trampas activas e inactivas.

``` sh
paco_el_chato haz-mapa
```

### Requerimientos
En la carpeta de trabajo deben existir los archivos:
- IG_MAPSOURCE_TRAMPAS_{fecha}.txt: Archivo que obtenemos de MapSource
- IG_POSICION_TRAMPAS_{fecha}.xlsx: Archivos con los esfuerzos de la semana

Al final generará el archivo `map_of_traps.jpg`.

### Posibles fuentes de error
Si las fechas no coinciden es posible que el mapa que generamos sea incorrecto.
Si la fecha del archivo de MapSource está una semana atrás al de posición todas las trampas aparecerán desactivas.
Por ejemplo, con los archivos `IG_POSICION_TRAMPAS_19NOV2023` e `IG_MAPSOURCE_TRAMPAS_12NOV2023.txt` obtendremos un mapa con todas las trampas desactivadas. 
Esto se debe a que a partir del archivo de MapSource generamos un nuevo archivo csv con fecha de una semana después.
Este archivo reescribe el original poniendo todas las trampas desactivas.


## `clasifica-fotos`
Clasifica las fotos que vienen de las trampas cámara.

``` sh
paco_el_chato clasifica-fotos
```

### Requerimientos
En la carpeta de trabajo debe estar una carpeta (o varias carpetas) con las fotos.
El nombre de la carpeta principal debe ser sin espacios. Por ejemplo:
- `FOTOS GATOS`: es un nombre incorrecto,
- `FOTOS_GATOS`: es un nombre correcto.


Al final generará la carpeta `cat_detected` con las fotos en las que detectó gato.

## `actualiza-comandos`
Actualiza los comandos:
- `haz-mapa`
- `clasifica-fotos`