semvec/pypi-packages huggingface dataset:
memberjojo 3.2.1
memberjojo - tools for working with members.
Requires Python: >=3.8

# memberjojo

`memberjojo` is a Python library for using [Membermojo](http://membermojo.co.uk/)
data from CSV imports.\
It provides member database, and completed payments querying.\
This is done in a local SQLite database which is optionally encrypted if sqlcipher3
is installed, and does not alter anything on Membermojo.\
It provides tools to load, and query membership and transaction data efficiently
without having to use SQLite directly.\
When importing CSV files existing entries are dropped before import, so you can
just import the latest download and the local database is updated with a summary
diff printed out.

Using the download_csv function the csv can be downloaded directly into the db,
which can also be in memory if :memory: is used as the db path.

---

## Installation

Installing via `pip` on macos with optional `sqlcipher` installed via homebrew:\
(The sqlcipher bindings are compiled by pip so the `C_INCLUDE_PATH` and
`LIBRARY_PATH` are needed for the `libsqlcipher` files to be found)

```bash
brew install sqlcipher
export C_INCLUDE_PATH="/opt/homebrew/opt/sqlcipher/include"
export LIBRARY_PATH="/opt/homebrew/opt/sqlcipher/lib"
pip install memberjojo[sqlciper]
```

Installing via `pip` on ubuntu:

```bash
sudo apt-get --no-install-recommends --no-install-suggests install libsqlcipher-dev
pip install memberjojo[sqlcipher]
```

Installing via `pip` without sqlcipher:

```bash
pip install memberjojo
```

Or clone the repo and install locally with `flit`:

```bash
git clone https://github.com/a16bitsysop/memberjojo.git
cd memberjojo
flit install --symlink
```

## Usage

Example loading members and using Member objects:

```python
from pathlib import Path
from membermojo import Member

# database is created if it does not exist
member_database_path = Path(Path(__file__).parent, "database", "my-members.db")
member_csv_path = Path("download", "members.csv")

members = Member(member_database_path, "My DB Password")
members.import_csv(member_csv_path)

for member in members:
    print(member.first_name, member.last_name, member.member_number)

# Get full name for a given member number
found_name = members.get_name(1)
if found_name:
    print(f"Member with id of 1 is {found_name}")
else:
    print("Member 1 does not exist")
```

## Documentation

Full documentation is available at  
👉 [https://a16bitsysop.github.io/memberjojo/](https://a16bitsysop.github.io/memberjojo/)

---

## Running Tests

Run tests:

```bash
pytest
```

## Contributing

Contributions are welcome! Please:

1. Fork the repo
2. Create your feature branch `git checkout -b my-feature`
3. Edit the source code to add and test your changes
4. Commit your changes `git commit -m 'Add some feature'`
5. Push to your branch `git push origin my-feature`
6. Open a Pull Request

Please follow the existing code style and write tests for new features.

---

## License

This project is licensed under the MIT [MIT License](https://github.com/a16bitsysop/memberjojo/blob/main/LICENSE).

---

## Contact

Created and maintained by Duncan Bellamy.
Feel free to open issues or reach out on GitHub.

---
water-column-sonar-annotation 26.2.1
Processing Tool for Working with Water Column Sonar Annotations
Requires Python: >=3.12
Keywords: ocean, sonar, water column

# Water Column Sonar Annotation

Tool for converting EVR files to annotated regions of interest in parquet format

![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/CI-CMG/water-column-sonar-annotation/test_action.yaml)
![PyPI - Version](https://img.shields.io/pypi/v/water-column-sonar-annotation) ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/CI-CMG/water-column-sonar-annotation) ![GitHub repo size](https://img.shields.io/github/repo-size/CI-CMG/water-column-sonar-annotation)

# Setting up the Python Environment

> Python 3.12.12

# Installing Dependencies

```
source .venv/bin/activate

uv pip install --upgrade pip

uv pip install -r pyproject.toml --all-extras

uv run pre-commit install
```

# Pytest

```
uv run pytest tests -W ignore::DeprecationWarning
```

or
> uv run pytest tests/cruise --cov=water_column_sonar_annotation --cov-report term-missing

```
uv run pre-commit install --allow-missing-config
# or
uv run pre-commit install
```

# Test Coverage

TODO

# Tag a Release

Step 1 --> increment the semantic version in the zarr_manager.py "metadata" & the "pyproject.toml"

```commandline
git tag -a v26.2.0 -m "Releasing v26.2.0"
git push origin --tags
gh release create v26.2.0
```

# To Publish To PROD

```commandline
uv build --no-sources
uv publish
```

# UV Debugging

```
uv lock --check
uv lock
uv sync --extra dev
#uv run pytest tests
```

## Annotation format

- https://roboflow.com/formats/coco-json
- https://www.v7labs.com/blog/coco-dataset-guide
mlux-reactly 0.2
ReAct inspired Agent developed from scratch using Ollama. This agent uses task decomposition and uses provided tools.
Requires Python: >=3.12

# MLUX-Reactly Agent Framework
A ReAct inspired Agent developed from scratch using Ollama. This agent uses task decomposition and uses provided tools.

## Installation

### A virtual environment is recommended:
```sh
python3 -m venv .venv
source .venv/bin/activate
```

### From PIP
```sh
pip install mlux-reactly
```

### From Source
```sh
pip install git+https://github.com/d-volution/mlux-reactly.git
```

### Setting up Ollama
You also have to setup Ollama. See the [README of Ollama](https://github.com/ollama/ollama/blob/main/README.md) for that.

The agent uses by default the Ollama model `qwen2.5:7b-instruct-q8_0`, but can be configured via the `llm` keyword argument.
The demo RAG-tool included within this repository uses the embedding model `nomic-embed-text`.
```sh
ollama pull qwen2.5:7b-instruct-q8_0
ollama pull nomic-embed-text
```

## Usage
```python
from typing import Annotated
from mlux_reactly import ReactlyAgent, LLM

def count_substr(a: Annotated[str, "Some string"], b: Annotated[str, "substring to be counted"]) -> int:
    """This tool calculates how often string b occures in string a"""
    if not b:
        return 0
    return sum(1 for i in range(len(a) - len(b) + 1) if a[i:i+len(b)] == b)

agent = ReactlyAgent(tools=[count_substr], llm=LLM("qwen2.5:7b-instruct-q8_0"))

answer = agent.query("How many times does the letter l occure in 'artificial general intelligence'?")
print(f"agent answer: {answer}")
```

---

## How to trace

Use LIVE_VERBOSE for printing the most important events live:
```python
from mlux_reactly.tracer import TestTracer, LIVE_VERBOSE
# ...
agent = ReactlyAgent(tracer=TestTracer(live_format=LIVE_VERBOSE))
```

Or to print only `toolrun`s and `result`s without highlight colours live:
```python
from mlux_reactly.tracer import TestTracer, FormatConfig
# ...
agent = ReactlyAgent(tracer=TestTracer(live_format=FormatConfig(show=['toolrun', 'result'], colored=False)))
```

### These are the existing events:
|key|description|
|-|-|
|query|an `agent.query()` call|
|task|subtask the query is splitted into|
|stage|a stage doing a LLM call with one specific prompt. If it fails, it might retry resulting in multiple LLM calls.|
|llmcall|a single call of the LLM. Only shows up in trace if not in compact mode| 
|toolrun|The invocation of a user-supplied tool|
|root|Root node of tracer|
|failed|Some step/operation that failed|
|result|The operation of the parent event finished with some result|


## When running from Git Repo

### Local Install
```sh
pip install -r requirements.txt
```

### Run simple chatbot
```sh
python3 test/chat.py
```

## Evaluation
To evaluate the agent, you can use `eval.py` like this:
```sh
python3 test/eval.py -agents <agent names> -tests <test names with test params>
```

For example, use
```sh
python3 test/eval.py -agents reactly llama-react -tests hotpot/train:100:3
```
to run the 'hotpot' test with the examples from index 100 to 103 on both the Reactly and the Llama-ReAct agents.