semvec/pypi-packages huggingface dataset:
geostats 1.0.0
A suite of geostatistical tools.
Requires Python: >=3.7
Keywords: geostats

# geostats: A suite of geostatistical tools

This repository provides a suite of geostatistical tools, including functions to compute the ground-motion correlation structure according to the relations by Bodenmann et al. (2023), and to do Kriging interpolation.


## Examples
- [Example 1 (Python backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example1_Python.ipynb): Ordinary Kriging using the $\rho_{E}$ correlation model. 
- [Example 1 (Cython backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example1_Cython.ipynb): Ordinary Kriging using the $\rho_{E}$ correlation model. 
- [Example 2 (Python backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example2_Python.ipynb): Ordinary Kriging using the $\rho_{EA}$ correlation model. 
- [Example 2 (Cython backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example2_Cython.ipynb): Ordinary Kriging using the $\rho_{EA}$ correlation model. 
- [Example 3 (Python backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example3_Python.ipynb): Ordinary Kriging using a user-defined correlation model. 
- [Example 3 (Cython backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example3_Cython.ipynb): Ordinary Kriging using a user-defined correlation model. 
- [Example 4 (Python backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example4_Python.ipynb): Krige a map using a user-defined correlation model. 
- [Example 4 (Cython backend)](https://github.com/RPretellD/geostats/blob/main/examples/Example4_Cython.ipynb): Krige a map using a user-defined correlation model. 


## Acknowledgements
- Implementation of the Kriging code benefited from Scott Brandenberg's [random field](https://github.com/sjbrandenberg/ucla_geotech_tools/tree/main/src/ucla_geotech_tools) python package.
- Some of the cython functions to compute ground-motion correlation are based on Lukas Bodenmann's [python functions](https://github.com/bodlukas/ground-motion-correlation-bayes).


## Citation
If you use these codes, please cite:<br>
Pretell, R. (2026). geostats: A suite of geostatistical tools (v1.0.0). Zenodo. https://doi.org/10.5281/zenodo.10253690 <br>

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10253690.svg)](https://doi.org/10.5281/zenodo.10253690)


## Contact
For any questions or comments, contact Renmin Pretell (rpretell at unr dot edu).
pykappa 0.1.8
Work with Kappa rule-based models in Python
Requires Python: >=3.12

<div align="center">
  <img src="https://raw.githubusercontent.com/berkalpay/pykappa/main/docs/source/_static/logo.png" width="100">
</div>

# PyKappa

[![PyPI](https://img.shields.io/pypi/v/pykappa)](https://pypi.org/project/pykappa)

PyKappa is a Python package for working with rule-based models.
It supports simulation and analysis of a wide variety of systems whose individual components interact as described by rules that transform these components in specified ways and at specified rates.
See our website [pykappa.org](https://pykappa.org) for a tutorial, examples, and documentation.


## Development
Developer requirements can be installed via:
```
pip install -r requirements.txt
```

<details>
<summary> With uv (optional alternative to pip): </summary>
Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:

```
uv sync --dev
```

To access `uv` dependencies, run your commands through `uv` like
```
uv run python
```

Or, if you want to run commands normally, create a virtual environment:
```
uv venv # Do this once
source .venv/bin/activate # Do this every new shell
```
and run commands as usual. (`deactivate` exits the venv.)

Adding a Python package dependency (this automatically updates pyproject.toml):
```
uv add [package-name]
```

Adding a package as a dev dependency:
```
uv add --dev [package-name]
```
</details>

To run correctness tests, run `pytest`.
Running `./tests/cpu-profiles/run_profiler.sh` will CPU-profile predefined Kappa models and write the results to `tests/cpu-profiles/results`.
We use the Black code formatter, which can be run as `black .`
ptal-api 1.0.0a25
TALISMAN API adapter
Requires Python: <4.0,>=3.10

# ptal-api

Python adapter for Talisman-based app

How to create trivial adapter:

    graphql_url = 'https://demo.talisman.ispras.ru/graphql' # or another talisman-based app
    auth_url = 'https://demo.talisman.ispras.ru/auth/'
    realm = 'demo'
    client_id = 'web-ui'
    client_secret = '<some-secret>'

    gql_client = KeycloakAwareGQLClient(
        graphql_url, 10000, 5,
        auth_url=auth_url,
        realm=realm, client_id=client_id, user='admin', pwd='admin',
        client_secret=client_secret
    ).__enter__()

    adapter = TalismanAPIAdapter(gql_client, {})

    c = adapter.get_concept('ОК-123456')
strongmind-deployment 1.1.296
Deployment tools for Strongmind
Requires Python: >=3.9

# StrongMind Deployment

## What?
Deployment scripts for StrongMind, using Pulumi.

## Development
Write pytest tests for functionality you need. When you need to use this with real AWS resources in a development environment, you'll need to follow these steps.

* Log your shell into the AWS account you're test deploying to (If you don't already have access keys set up, you can find how to do this in the [Amazon SSO portal](https://strongmind.awsapps.com/start#/), under "Programmatic Access")
* Find the relevant container image you're deploying [from ECR](https://us-west-2.console.aws.amazon.com/ecr/repositories?region=us-west-2). (Choose the relevant project container, then the image tag, and then copy the URI field).
* Find the Rails Master Key for that project. Usually this is kept in the [github actions secrets](https://github.com/StrongMind/frozen-desserts/settings/secrets/actions) for that project.
* Get the cloudflare API token and pulumi state passwords from bitwarden if you have access, or get this from devops otherwise.
* Use these to construct an environment in your preferred fashion with the following keys
  * CONTAINER_IMAGE
  * RAILS_MASTER_KEY
  * CLOUDFLARE_API_TOKEN
  * PULUMI_CONFIG_PASSPHRASE
* In the project that you are testing with, in the infrastructure directory, there will be a requirements.txt file. In order to use your development code, rather than the published version of this library, you will need to change the line that says "strongmind_deployment" to `-e /path/to/this/directory`, using the directory that this README is located in.
* Reinstall the requirements in your pulumi infrastructure directory. Usually this looks like 
```shell
source venv/bin/activate
pip install -r requirements.txt
```

You can now use pulumi commands like `pulumi preview` and `pulumi up` to make changes.

We usually use the [frozen-desserts](https://github.com/StrongMind/frozen-desserts) application to do simple tests of a non-production application.
dynamodx 0.1.2
Developer-friendly library for DynamoDB with single-table design, without ORM lock-in.
Requires Python: >=3.11
Keywords: aws, database, dynamodb

## Dynamodx

A developer-friendly library for DynamoDB, simplifying single-table design without ORM lock-in.

```python
from dynamodx.transact_writer import TransactWriter, TransactionOperationFailed

class EmailConflictError(TransactionOperationFailed):
    pass

try:
    with TransactWriter(table_name=..., client=...) as transact:
        transact.put(
            item={
                'pk': user_id,
                'sk': '0',
                'name': name,
                'email': email,
                'phone': phone,
            }
        )
        transact.put(
            item={
                'pk': f'EMAIL',
                'sk': email,
                'user_id': user_id,
            },
            cond_expr='attribute_not_exists(sk)',
            return_on_cond_fail='ALL_OLD',
            exc_cls=EmailConflictError,
        )
except EmailConflictError as err:
    # Got existing `user_id`
    user_id = err.reason['old_image']['user_id']
```

## License

Dynamodx is open-source software licensed under the [MIT License](LICENSE).
cynsta-spendguard 0.2.0
SpendGuard SDK and CLI
Requires Python: >=3.11
Keywords: cynsta, spendguard, sdk, cli, budget, llm

# SpendGuard SDK

Public SpendGuard repository for:

- Python CLI package (`cynsta-spendguard`)
- Python client library (`spendguard_sdk`)
- API contracts (`contracts/`)
- Public examples and docs

Supported provider endpoint families: `openai`, `grok` (xAI), `gemini`, `anthropic`.

## Install

```bash
pip install cynsta-spendguard
```

or with uv:

```bash
uv tool install cynsta-spendguard
```

## Quickstart

For fast local onboarding with `spendguard-sidecar`, follow [`docs/quickstart.md`](docs/quickstart.md).

## Usage

Create an agent:

```bash
spendguard agent create --name "agent-1"
```

List agents:

```bash
spendguard agent list
```

Get an agent:

```bash
spendguard agent get --agent <agent_id>
```

Rename an agent:

```bash
spendguard agent rename --agent <agent_id> --name "agent-1-renamed"
```

Delete an agent:

```bash
spendguard agent delete --agent <agent_id>
```

Set a budget for an existing agent:

```bash
spendguard budget set --agent <agent_id> --limit 5000 --topup 5000
```

Get current budget:

```bash
spendguard budget get --agent <agent_id>
```

Key behavior:

- `CAP_MODE=sidecar` (default): no `x-api-key` is required.
- `CAP_MODE=hosted`: API key is required via `--api-key` or `CAP_API_KEY`.

## Release

Build locally:

```bash
python -m pip install --upgrade build twine
python -m build .
python -m twine check dist/*
```

Publish:

1. Set GitHub secret `PYPI_API_TOKEN`.
2. Push tag `spendguard-cli-vX.Y.Z` (example `spendguard-cli-v0.1.0`).
3. GitHub Actions workflow `.github/workflows/publish-spendguard-cli.yml` publishes to PyPI.

Maintainer setup checklist: `docs/maintainer-setup.md`.

## Python Client

```python
from spendguard_sdk import SpendGuardClient

client = SpendGuardClient("https://spendguard.example.com", api_key="sk_cynsta_live_...")
agent = client.create_agent("agent-1")
client.set_budget(agent["agent_id"], hard_limit_cents=5000, topup_cents=5000)
run = client.create_run(agent["agent_id"])
resp = client.grok_responses(
    agent["agent_id"],
    run["run_id"],
    {"model": "grok-3", "input": "Give me a one-line summary of finite-state machines."},
)
```
nogic 0.0.4
Codebase Visualization for Developers and AI Agents — index, search, and understand codebases via graph + vector embeddings.
Requires Python: >=3.11
Keywords: ai-agents, code-graph, code-intelligence, embeddings, mcp, tree-sitter

# Nogic CLI

Codebase Visualization for Developers and AI Agents.

## Installation

### Prerequisites

- Python 3.11 or higher

### Install with pipx (Recommended)

```bash
pipx install nogic
```

### Install with pip

```bash
pip install nogic
```

## Quick Start

### 1. Log in

```bash
nogic login
```

This opens your browser for authentication via your [Nogic account](https://nogic.dev).

### 2. Initialize a project

```bash
cd /path/to/your/project
nogic init
```

This creates a `.nogic/` directory with project configuration.

### 3. Sync your codebase

One-time sync:

```bash
nogic sync
```

Or watch for continuous syncing:

```bash
nogic watch
```

## Commands

- `nogic login` — Authenticate via browser
- `nogic init` — Initialize a project in a directory
- `nogic watch` — Watch for file changes and sync continuously
- `nogic sync` — One-time full sync
- `nogic reindex` — Wipe graph data and re-index from scratch
- `nogic status` — Show project configuration and backend status
- `nogic projects list` — List all your projects
- `nogic projects create` — Create a new project
- `nogic projects use` — Switch the current project
- `nogic telemetry disable` — Opt out of anonymous telemetry

See the full [CLI reference](https://docs.nogic.dev/cli/commands) for all options.

## Supported Languages

- Python (`.py`)
- JavaScript (`.js`, `.jsx`)
- TypeScript (`.ts`, `.tsx`)

## Data & Privacy

### What we store

When you sync your codebase, Nogic stores the following in our graph database:

- **Code structure** — Function and class signatures, call relationships, import/export graphs
- **File metadata** — File paths, hashes, and modification timestamps
- **Embeddings** — Vector representations of code for semantic search

We do **not** store raw source code, comments, string literals, or any secrets/credentials.

### Telemetry

Nogic collects anonymous usage telemetry to help improve the product:

- CLI version, OS, Python version
- Command names (e.g., `cli_login`, `cli_sync`)
- An anonymous ID (SHA-256 hash of your access token or machine info)

### Opt out of telemetry

```bash
nogic telemetry disable
```

Or set `NOGIC_TELEMETRY_DISABLED=1` or `DO_NOT_TRACK=1`.

For full details, see our [Privacy Policy](https://nogic.dev/privacy).

## Documentation

Full documentation at [docs.nogic.dev](https://docs.nogic.dev).

## License

MIT
likelihood 2.1.9
A package that performs the maximum likelihood algorithm.
Requires Python: >=3.10

![likelihood](https://raw.githubusercontent.com/jzsmoreno/likelihood/main/likelihood.png)

![GitHub last commit](https://img.shields.io/github/last-commit/jzsmoreno/likelihood?style=for-the-badge)
![GitHub repo size](https://img.shields.io/github/repo-size/jzsmoreno/likelihood?style=for-the-badge)
![License](https://img.shields.io/github/license/jzsmoreno/likelihood?style=for-the-badge)

<!-- Project description -->
This repository contains the code to build the [likelihood package](./likelihood/) which contains tools for typical tasks in maintain machine learning models in production and the training of custom models, for more information review our [`documentation`](https://jzsmoreno.github.io/likelihood/).

## Prerequisites

Before you begin, ensure you have met the following requirements:

* You have a _Windows/Linux/Mac_ machine running [Python 3.10+](https://www.python.org/).
* You have installed the latest versions of [`pip`](https://pip.pypa.io/en/stable/installing/) and [`virtualenv`](https://virtualenv.pypa.io/en/stable/installation/) or `conda` ([Anaconda](https://www.anaconda.com/distribution/)).

## Installation

This package can be easily installed with pip:
```bash
pip install likelihood
```

## Examples

You can check the [examples](https://github.com/jzsmoreno/likelihood/tree/main/examples) folder.

More examples will be added soon.