semvec/pypi-packages huggingface dataset:
ndx-conelab 0.2.0
NWB extension for custom Task Parameters used in the Cone Lab.
Requires Python: >=3.8

# ndx-conelab

NWB extension for custom Task Parameters used in the Cone Lab.

This package provides the NWB extension definition (YAML) and Python API 
for storing and retrieving Cone Lab-specific task parameters within NWB 2.0 files.

## Installation

```bash
pip install ndx-conelab
```
(Once published to PyPI)

Or, for local development:
```bash
git clone https://github.com/JConeLab/ndx-conelab.git # Or your repo URL
cd ndx-conelab
pip install -e .
```

## Usage

Once installed, PyNWB will automatically be able to read NWB files containing
the `conelab.TaskParameters` neurodata type.

To create this data type in a new NWB file:

```python
from pynwb import NWBHDF5IO, NWBFile
from datetime import datetime
from ndx_conelab import TaskParameters # Import the custom class

# ... (create your NWBFile object) ...
nwbfile = NWBFile(
    session_description='My session description',
    identifier='MY_SESSION_ID',
    session_start_time=datetime.now().astimezone(),
    # ... other required fields ...
)

# Create an instance of your custom TaskParameters
conelab_task_params = TaskParameters(
    name="MyExperimentTaskParams", # Name is required (from LabMetaData parent)
    reaction_time_window_ms=1000,
    intertrial_interval_ms=2000,
    iti_jitter_percentage=0.2,
    # ... fill in other parameters as needed ...
    description="Parameters for the RDK task, easy difficulty."
)

# Add the TaskParameters object to the NWB file.
# Since TaskParameters inherits from LabMetaData, it can be added directly
# using add_lab_meta_data(). PyNWB will typically store this under 
# /general/lab_meta_data/<object_name>/ 
# (e.g., /general/lab_meta_data/MyExperimentTaskParams/ in this case)
nwbfile.add_lab_meta_data(conelab_task_params)

# ... (write your NWB file) ...
# with NWBHDF5IO('test_nwb_with_conelab_extension.nwb', 'w') as io:
#     io.write(nwbfile)
```

## Extension Definition

The extension schema is defined in `ndx_conelab/spec/`:
* `conelab.namespace.yaml`
* `conelab.extensions.yaml`

This defines a `TaskParameters` group inheriting from `LabMetaData` to store various experimental parameters.
AgentToAgent 0.1.0
A modern way to let AI-agents Communicate
Requires Python: >=3.10

﻿
---

**AgentToAgent** is a zero-dependency, production-ready message router for agent-to-agent communication in Python.  
It lets you send and receive messages between named agents—perfect for coordinating tasks in multi-agent systems, toolchains, or even distributed apps.

---

## Install

```sh
pip install AgentToAgent
````

---

## Usage

```python
from AgentToAgent import AgentToAgent

ata = AgentToAgent()

# Send a message from one agent to another
ata.send("Alpha", "Bravo", "Ping from Alpha!")

# Agent Bravo receives their messages
messages = ata.receive("Bravo")
print(messages)
# Output: [{'from': 'Alpha', 'to': 'Bravo', 'content': 'Ping from Alpha!'}]

# Support for filtering by sender
ata.send("Alpha", "Charlie", "Hello, Charlie!")
ata.send("Beta", "Charlie", "Hi, Charlie!")
msgs = ata.receive("Charlie", allowedFrom=["Beta"])
print(msgs)
# Output: [{'from': 'Beta', 'to': 'Charlie', 'content': 'Hi, Charlie!'}]
```

---

## Features

* **Direct agent-to-agent messaging** – Send and receive by agent name.
* **Broadcasting** – Send to all by using `toAgent=None`.
* **Filtered receive** – Optionally receive only from allowed senders.
* **In-memory queue** – Each receive call pulls all available messages.
* **Zero dependencies** – No third-party packages required.
* **Works with any agent framework** – Simple plug-and-play for any system.

---

## Code Examples

You can find code examples on my [GitHub repository](https://github.com/TristanMcBrideSr/TechBook).

---

## License

Apache License 2.0

---

## Acknowledgements

Project by:
- Tristan McBride Sr.
- Sybil
cortex-axon-sdk 0.0.4
Cortex Axon Python SDK
Requires Python: <4.0,>=3.9

# Cortex Axon SDK for Python

This is the official Cortex Axon SDK for Python. It provides a simple way to interact with and extend your Cortex instance.

## Getting started

To run the Cortex SDK you need to get the Axon Agent via Docker:

```
docker pull ghcr.io/cortexapps/cortex-axon-agent:latest
```

Then to scaffold a Python project:

```
docker run -it --rm -v "$(pwd):/src" ghcr.io/cortexapps/cortex-axon-agent:latest init --language python my-python-axon project
```

This will create a new directory `my-python-axon` with a Go project scaffolded in the current directory.

## Running locally

To run your project, first start the agent Docker container like:

```
docker run -it --rm -p "50051:50051" -p "80:80" -e "DRYRUN=true" ghcr.io/cortexapps/cortex-axon-agent:latest serve
```

This is `DRYRUN` mode that prints what it would have called, to run against the Cortex API remove the `DRYRUN` environment variable and add `-e "CORTEX_API_TOKEN=$CORTEX_API_TOKEN`.  Be sure to export your token first, e.g. `export CORTEX_API_TOKEN=your-token`.


## Adding handlers

To add a handler, open `main.py` and create a function:

```python

@cortex_scheduled(interval="5s")
def my_handler(ctx: HandlerContext):

    payload = {
        "values": {
            "my-service": [
                {
                    "key": "exampleKey1",
                    "value": "exampleValue1",
                },
                {
                    "key": "exampleKey2",
                    "value": "exampleValue2",
                },
            ]
        }
    }

    json_payload = json.dumps(payload)

    response = ctx.cortex_api_call(
        method="PUT",
        path="/api/v1/catalog/custom-data",
        body=json_payload,
    )

    if response.status_code >= 400:
        ctx.log(f"SetCustomTags error: {response.body}", level="ERROR")
        exit(1)

    ctx.log("CortexApi PUT custom-data called successfully!")

@cortex_webhook(id="my-webhook-1")
def my_webhook_handler(context: HandlerContext):
    context.log("Success! Webhook handler called!")
    body = context.args["body"]
    context.log(f"Webhook body: {body}")

```

Now start the agent in a separate terminal:
```
make run-agent
```

And run your project:
```
python main.py
```

This will begin executing your handler every 5 seconds. 
To invoke the webhook handler, you can just send a POST request to `http://localhost:80/webhook/my-webhook-1` with a body.
saic_ismart_client_ng 0.9.2
SAIC next gen client library (MG iSMART)
Requires Python: >=3.11

# SAIC Python client library

## About

A Python package for interacting with the MG iSMART API.

MG iSMART is the connectivity system in your MG car (MG5 MG4, ZS...).

Supported functionality (partial list, check the code for more)

* login
* set alarm switches
* get message list
* get vehicle status
* get charging status
* lock vehicle
* unlock vehicle
* start rear window heating
* stop rear window heating
* remote climate
* heated seats


## Prerequisites

You have an iSMART account (can be created in the iSMART app)
lsprotocol 2025.0.0
Python types for Language Server Protocol.
Requires Python: >=3.8

# Language Server Protocol Types implementation for Python

`lsprotocol` is a Python implementation of object types used in the Language Server Protocol (LSP). This repository contains the code generator and the generated types for LSP.

## Overview

LSP is used by editors to communicate with various tools to enables services like code completion, documentation on hover, formatting, code analysis, etc. The intent of this library is to allow you to build on top of the types used by LSP. This repository will be kept up to date with the latest version of LSP as it is updated.

## Installation

`python -m pip install lsprotocol`

## Usage

### Using LSP types

```python
from lsprotocol import types

position = types.Position(line=10, character=3)
```

### Using built-in type converters

```python
# test.py
import json
from lsprotocol import converters, types

position = types.Position(line=10, character=3)
converter = converters.get_converter()
print(json.dumps(converter.unstructure(position, unstructure_as=types.Position)))
```

Output:

```console
> python test.py
{"line": 10, "character": 3}
```
sentry-script-runner 1.0.1
A web application for running Python scripts.
Requires Python: >=3.11

# script-runner

A tool for defining python functions, triggering their execution and displaying results via a user interface.

Used at Sentry to allow specific users to run predefined Python scripts on production data.


## Deployment modes

Multi-region deployments enable aggregating results across multiple "regions" or "silos", whilst still enabling script execution to be performed in a single region.
- set `mode: main` for the central region
- set `mode: region` for each instance of the application deployed in each regions


For a single deployment in one region use `mode:combined`. Currently we only use this for dev and testing.


## Writing custom scripts
Scripts are standard python functions organized into groups.

All of the arguments to a function must be annotated with one of the supported parameter types. The currently supported ones are:

- Text
- Textarea
- Integer
- Number
- Autocomplete
- DynamicAutocomplete

Example:
```python
def print_value(input: Text) -> None:
    """
    for short text, renders <input type="text" /> in the ui
    """
    print(input.value)

def print_long_value(input: TextArea) -> None:
    """
    multiline text, renders <textarea /> in the ui
    """
    print(input.value)
```

The annotation controls how the element is displayed in the UI, and the Python type of the value (`str`, `int` or `float`)

The return value of the function can be anything, as long as it is json serializable

Any functions exported by a module via `__all__` will be picked up automatically and displayed in the UI.


## Writing tests
Use the `execute_with_context` helper from the testutils module to call your function with mock values.


## Authentication
currently google iap (and no auth) are supported

for google iap, set the `audience_code` as well as `iap_principals` (group -> iap principal mapping) in the config


## Example data:
- These are in the examples/scripts directory

## Configuration
check `config.schema.json` for configuration format and required fields.
there is also an example of each mode in this repository: `example_config_combined.yaml`, `example_config_main.yaml`, `example_config_local.yaml`

## Development

- Run `make devserver`. The application will run on combined mode on `http://127.0.0.1:5000`

- If you want UI hot reloading, you have to run the vite server separately.
- Navigate to the frontend directory:
  ```bash
  cd script_runner/frontend
  ```
- Install dependencies if you haven't already:
  ```bash
  npm install
  ```
- Run the Vite development server:
  ```bash
  npm run dev
  ```
- The frontend should now be running on `http://localhost:5173` and will automatically proxy API requests to the backend thanks to the proxy configured in `vite.config.ts`.
mtrequests 2.1.1
threading for requests
Requires Python: >=3.6
Keywords: requests threading

# mtrequests
threading for requests

```python
import mtrequests

pp = mtrequests.PendingPool()

print(mtrequests.get("https://example.com").send())
print(mtrequests.get("https://example.com").wrap(pp).send())
print(pp.wrap(mtrequests.get("https://example.com")).send())
```

## New in 2.0.0+

```python
import mtrequests

session = mtrequests.Session()
session.set_tls_client_session()  # add tls-client session for requests
```
blackbit 0.0.2
CLI tool for file encryption/decryption
Requires Python: >=3.8

blackbit 🚀

A minimal Python CLI tool for streaming file encryption and decryption, with optional zipping, secure deletion, and Google Drive integration.

---

Overview

Blackbit enables encryption or decryption of single files or entire folders (zipped) without loading them fully into memory—ideal for large files. It also supports:
- Password-based encryption using cryptography.Fernet
- Progress bars powered by tqdm
- Optional upload/download to Google Drive
- Secure cleanup of temporary files
- USB drive detection
- A hybrid CLI and GUI interface for flexibility

---

Prerequisites

- Python 3.8 or newer
- The following pip-installed dependencies: cryptography, tqdm, psutil, google-auth, google-api-python-client, tkinter

---

Installation

Run:
    pip install blackbit

---

Usage

Execute:
    blackbit

You'll see an interactive menu:
    [1] Encrypt a file or folder
    [2] Decrypt a file
    [3] Exit

Workflow steps:
1. Choose encrypt or decrypt
2. Select the target file or folder using CLI or GUI
3. Choose whether to zip when encrypting a folder
4. Enter a password (converted into a Fernet key)
5. Watch a live progress bar
6. Optionally upload or download to/from Google Drive
7. Temporary files are securely deleted after use

---

Encryption Details

- Uses cryptography.Fernet for symmetric encryption (AES‑based, with authentication)
- Processes files in chunks with metadata headers—efficient and memory-safe, especially for large files
- Optional zipping before encryption using Python's zipfile

---

Project Structure

blackbit/
  __init__.py      (contains __version__)
  main.py          (CLI logic, encryption, Drive support, etc.)

README.txt         (project documentation)
LICENSE           (MIT license text)
pyproject.toml    (package/build configuration)

---

Changelog / Roadmap

Current version: 1.0.0

- [x] Streaming encryption & decryption
- [x] Folder zipping
- [x] Google Drive integration
- [x] Secure delete
- [x] Add unit tests
- [x] Improve error handling
- [x] Refactor into separate modules (crypto.py, drive.py, etc.)

---

Resources & References

- Use cryptography.Fernet for secure and authenticated symmetric encryption
- For large-file encryption, chunked streaming is essential to avoid high memory usage
- Clean, well-structured READMEs improve usability and attract contributors

---

Made with passion for secure, efficient secure tool💡
PuQTSqlite 0.1.1
A package to distribute your PyQt SQLite program files
Requires Python: >=3.6

# PuQTSqlite

Пакет для распространения файлов программы PyQt с SQLite.

## Установка

```bash
pip install PuQTSqlite
```

## Использование

```python
from PuQTSqlite import copy_file, list_available_files

# Посмотреть список доступных файлов
list_available_files()

# Скопировать файл в текущую директорию
copy_file('main.py')

# Скопировать файл в указанную директорию
copy_file('database.py', 'path/to/destination')
```

## Доступные файлы

- main.py
- database.py
- material_calc.py
- requirements.txt
- partners.db
- Мастер пол.png
sreeclassifier 1.0.0
Image classification using Vision Transformer (ViT)
Requires Python: >=3.7

# sreeclassifier

**sreeclassifier** is a Python package for general-purpose image classification based on the Vision Transformer (ViT) model with pretrained ImageNet weights. It currently supports classification of common everyday images into 1000+ classes.

## Upcoming Features

Upcoming versions will focus on aerial and satellite image classification, expanding the number of classes and improving accuracy tailored for remote sensing and aerospace applications.

## Features

- Easy-to-use API for image classification  
- Uses state-of-the-art Vision Transformer (ViT) architecture  
- Supports top-k predictions with confidence scores  
- Lightweight and ready for extension to domain-specific datasets  

## Installation

```bash
pip install sreeclassifier
PINN-kit 0.0.2
A toolkit for Physics-Informed Neural Networks
Requires Python: >=3.9

# PINN-kit

A toolkit for Physics-Informed Neural Networks (PINNs). This package provides tools and utilities for implementing and training physics-informed neural networks for solving differential equations.

## Features

- Easy-to-use interface for defining physics-informed neural networks
- Support for various types of differential equations
- Domain handling utilities
- Training and evaluation tools

## Installation

```bash
pip install PINN-kit
```

## Quick Start

```python
from PINN_kit import PINN, Domain

# Create a domain
domain = Domain(...)

# Initialize a PINN
pinn = PINN(...)

# Train the network
pinn.train(...)
```

## Documentation

For detailed documentation, please visit [our documentation page](https://github.com/shivani/PINN-kit).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
docc 0.3.1
Python code documentation compiler
Requires Python: >=3.10

docc
====

[![documentation badge][docs-badge]][docs]

The documentation compiler.

## Python Quickstart

### Installing

```bash
pip install docc
```

### Configuring

Add the following to your [`pyproject.toml`]:

```toml
[tool.docc.plugins."docc.python.discover"]
paths = [ "<path to Python source>" ]

[tool.docc.output]
path = "<where to put rendered documentation>"
```

### Building

Finally, to generate the documentation:

```bash
docc
```

[docs-badge]: https://github.com/SamWilsn/docc/actions/workflows/gh-pages.yaml/badge.svg?branch=master
[docs]: https://samwilsn.github.io/docc/
[`pyproject.toml`]: https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#declaring-project-metadata