semvec/pypi-packages huggingface dataset:
llamp 0.0.19
LLAMP - Large Language Model for Planning

# LLamp - Large Languge Models for Planning

This is a package that uses LLMs (closed and open-source) for planning and reasoning.

This package is under development. 

## Purpose of this package:
1. To help with running different LLMs (both local and API-based) in a unified manner.
2. To provide useful utility functions (such as counting tokens)
3. Automatic Tracking of the entire conversation with the agent


## Reference:
Please cite the paper StateAct: [https://arxiv.org/abs/2410.02810]
```bibtex
@article{rozanov2024stateactstatetrackingreasoning,
      title={StateAct: State Tracking and Reasoning for Acting and Planning with Large Language Models}, 
      author={Nikolai Rozanov and Marek Rei},
      year={2024},
      eprint={2410.02810},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2410.02810}, 
}
```
jupyter-jscomm 0.1.4
A package for JavaScript-Python communication in Jupyter notebooks
Requires Python: >=3.7

# jupyter-jscomm

A Python package to work around JavaScript-Python communication difficulties in Jupyter notebooks.
Basic strategy is to use a hidden widget holding a json payload with the variables you want to keep.

This code can for instance be used as a hack to copy the content of bokeh JS variables into these JS-Python accessible variables.


## Installation

```bash
pip install jupyter-jscomm
```

## Usage from a Jupyter notebook
```python
from jupyter_jscomm import JSComm

# Initialize the communication
comm = JSComm()

# Or initialize with custom class name to avoid collisions
comm1 = JSComm(class_name="my-comm-1")
comm2 = JSComm(class_name="my-comm-2")

# Each instance maintains its own state
comm1.add("var1", "Value for comm1")
comm2.add("var1", "Value for comm2")

# Add data from Python
comm1.add("var1", "Hello from Python")
comm2.add("var2", {"nested": "data"})

# Get data from JavaScript
value = comm1.get("var1")

# Update existing data
comm1.update("var1", "Updated value")

# Remove data
comm1.remove("var1")

# Clear all data
comm1.clear_all()
```

## Change JS variable from JS context
While this package ensures the creation of a "magic" JS variable (default class name "comm-class") where you can write from Python to JS and get the value back from JS to Python, one of the goal is to map an already existing variable to this "magic" JS variable

```javascript
// var my_existing_variable already contains the value I want to retrieve and expose in Python

// For default class name
var parent = document.getElementsByClassName("comm-class")[0];

// For custom class name
var parent = document.getElementsByClassName("my-comm-1")[0];

var input = parent.querySelector(".widget-input");
input.value = '{"var1": ' + JSON.stringify(my_existing_variable + '}';
input.dispatchEvent(new Event('input', { bubbles: true }));
```

## License
This project is licensed under the MIT License - see the LICENSE file for details.
hyperpocket_gemini 0.3.6
Add your description here
Requires Python: >=3.11

## Gemini extensions

### Binding Pocket Tools

```python
import os

from google import genai
from google.genai import types

from hyperpocket_gemini import PocketGemini

pocket = PocketGemini(tools=[
    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
    "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
])

# get gemini compatible tools from pocket
tools = pocket.get_gemini_tool_specs()
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
messages = []  # add system prompt here. 

response = client.models.generate_content(
    model='gemini-2.0-flash-001',
    contents=messages,
    config=types.GenerateContentConfig(tools=tools)
)
```

### Agent Examples

- See here: [link](/examples/gemini/tool-calling-agent/tool_calling_agent/agent.py)
filesrenamer 0.0.4
A simple Python module to rename all files in a folder
Requires Python: >=3

# filesrenamer
filesrenamer allows to rename all files in a folder instantly.First install filesrenamer using the standard installation.
```
pip install filesrenamer
``` 
After that go to the folder and open command prompt/terminal and run
```
filesrenamer new_name
```
where new_name is your choice of name for the files in that folder. Once you run this, all the files in that
folder will be renamed to new_name followed by a number starting from 1 for the first file and so on and 
then finally ending with the file extension for that particular file. For eg, if a folder contains apples.jpg and oranges.png 
and you run `filesrenamer grapes` then the files will become grapes1.jpg and grapes2.png.
telegram-channel-viewer 0.1.2
A Python module to view Telegram channel information

# telegram-channel-viewer

A Python library that lets you view Telegram channels, users, and groups ( ONLY BASIC INFORMATION!! ) without needing a Telegram account or API credentials.

## How It Works

The telegram-channel-viewer module parses public Telegram web pages to extract information:

1. Channel Information:
   - Fetches data from `https://t.me/{channel_name}`
   - Extracts metadata from OpenGraph tags
   - Parses subscriber count and channel details

2. Channel Messages:
   - Accesses `https://t.me/s/{channel_name}`
   - Retrieves message content, dates, and view counts
   - Extracts images and media from posts

3. Specific Posts:
   - Retrieves post data from `https://t.me/{channel_name}/{post_id}?embed=1&mode=tme`
   - Provides clean, formatted content
   - Extracts post media and metadata

## Installation

pip install git+https://github.com/bargmy/telegram-channel-viewer.git

## Examples

### Basic Channel Information
from telegram_channel_viewer import channel

# Initialize channel viewer
ch = channel("durov")

# Get basic channel info
print(f"Channel Name: {ch.channel_name}")
print(f"Description: {ch.channel_description}")
print(f"Subscribers: {ch.channel_subs}")
print(f"Profile Picture: {ch.channel_profile}")

### Get Channel Messages
# Get all messages
messages = ch.messages
print(messages)  # Returns JSON with message content and URLs

# Get all images
images = ch.images
print(images)  # Returns JSON with image URLs

### Get Specific Post
post = ch.post("1234")

print(f"Content: {post.content}")
print(f"Posted on: {post.date}")
print(f"Views: {post.views}")
print(f"Images: {post.images}")

## Features
- No Telegram API key required
- Works with public channels, groups, and users
- Extracts text content, images, and videos
- JSON output format
- Simple and lightweight

## Dependencies
- requests
- beautifulsoup4

## License
MIT License

## Credits
Developed by Claude 3.5
npdoc-cli 0.0.2
Tool for creating command line interfaces derived from numpy style doc strings.
Requires Python: >=3.12

# npdoc-cli
A tool built with [argparse](https://docs.python.org/3/library/argparse.html)
that utilizes the [numpy style guide](https://numpydoc.readthedocs.io/en/latest/format.html)
to generate a command line interface (CLI). Paired with auto-generated
documentation with [sphinx](https://www.sphinx-doc.org/en/master/) you can
maintain a function's source code, documentation, and CLI all with the same
chunk of text.

For example a simple CLI for a function can be made with:

```python
from npdoc_cli import cli

@cli.program
def hello(name: str):
    """
    Say hello!

    Parameters
    ----------
    name : str
        Who is being greeted.
    """
    print('hello', name)

cli.build()
cli.print_help()
```

Which produces a help message like:

```console
usage: hello [-h] name

Say hello!

positional arguments:
  name        Who is being greeted.

optional arguments:
  -h, --help  show this help message and exit
```

Install with pip.

```console
pip install npdoc-cli
```

For more information, check out the [documentation](https://d-c-gray.github.io/npdoc-cli/).
adess 1.0.0
A package for ADESS
Requires Python: >=3.8

## Introduction
This is the code for my master's thesis: <a href="Master Thesis with affidavit.pdf">Anomaly Detection Using an Ensemble with Simple Sub-models, 2024</a>.
The algorithm explores the effectiveness of an ensemble of simple sub-models like linear regression in detecting anomalies.


## Installation
Install the package


# Parameters
Run with --help to see the parameters
```
adess --help
```
```
usage: adess [-h] --train TRAIN --test TEST [--feat_sel_percent FEAT_SEL_PERCENT] [--max_feats MAX_FEATS] [--order ORDER] [--computation_budget COMPUTATION_BUDGET] [--no_submodels NO_SUBMODELS] [--prep PREP] [--extract EXTRACT]
             [--submodel SUBMODEL]

ADESS: Anomaly Detection using Ensemble of simple sub=models

options:
  -h, --help            show this help message and exit
  --train TRAIN         Training data (default: None)
  --test TEST           Testing data (default: None)
  --feat_sel_percent FEAT_SEL_PERCENT
                        Feature selection percentage (default: 0.2)
  --max_feats MAX_FEATS
                        Maximum number of features (default: 50)
  --order ORDER         Degree of polynomials for feature bagging (default: 2)
  --computation_budget COMPUTATION_BUDGET
                        Computation budget in seconds (default: 600)
  --no_submodels NO_SUBMODELS
                        Count of submodels in the ensemble (default: 500)
  --prep PREP           List of preprocessing options (choose one or many): [skel,canny,clahe,blur,augment,gray,norm,std,none] (default: ['norm'])
  --extract EXTRACT     Feature selection option (choose one): [rbm,tsne,pca,ica,nmf,ae,none] (default: pca)
  --submodel SUBMODEL   Submodel type option (choose one): [lin,lasso,elastic,svm] (default: lin)
```


# CLI

```
adess --train path/to/train --test path/to/test
```

Example:
```
adess --train train.npy --test test.npy
```
Output:
```
X_train.shape = (353, 10), X_test.shape = (89, 10), 'feat_sel_percent = 0.2', 'max_feats = 50', 'order = 2', 'computation_budget = 600', 'no_submodels = 500', 'prep = norm', 'extract = pca', 'submodel = lin'
100%|█████████████████████████████████████████| 500/500 [00:00<00:00, 1094.41it/s]
Mean of Predicted Y = 8.005149077019986e-32, Count of submodel executed = 500
```


# Python
1. Import the sklearn diabetes dataset as an example.
2. Split and load the dataset to the adess() function. X_test will be used to predict 'y'.
3. The mean prediction (of y) and the (default) ensemble size are printed.

```
>>> from adess.adess import adess
>>> from sklearn.datasets import load_diabetes
>>> from sklearn.model_selection import train_test_split
>>> X, y= load_diabetes(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
>>> adess(X_train,X_test)
100%|█████████████████████████████████████████| 500/500 [00:00<00:00, 1162.27it/s]
(3.2565381430216842e-31, 500)
>>> 
```


## Results from the thesis experiments
The AUROCs of the runs reported in the thesis are stored in this <a href="https://docs.google.com/spreadsheets/d/1lLax3dy0JjQOxW_wwGM35UwRHdO8CJlR9QSlvxNbVNc/edit?usp=sharing">Google Sheet</a>
endc 1.0.1
Encryption and decryption library
Requires Python: >=3.6

# endc Library

ATM هي مكتبة Python تتيح عمليات التشفير وفك التشفير بسهولة باستخدام خوارزميات حديثة.

## المميزات
- تشفير وفك تشفير النصوص والبيانات بسهولة.
- دعم خوارزميات تشفير قوية.
- واجهة برمجية بسيطة وسهلة الاستخدام.

## التثبيت

لتثبيت المكتبة عبر `pip`، استخدم الأمر التالي:

```sh
pip install endc
```

## كيفية الاستخدام

### 1. استيراد المكتبة
```python
from endc import Word_Enc, Word_Dec
```

### 2. تشفير النصوص
```python
text = "Hello, World!"
encrypted_text = endc.Word_Enc(text, key="mysecretkey")
print(encrypted_text)
```

### 3. فك التشفير
```python
decrypted_text = endc.Word_Dec(encrypted_text, key="mysecretkey")
print(decrypted_text)
```

## المتطلبات
- Python 3.6 أو أحدث

<!-- ## المساهمة
نرحب بالمساهمات في تطوير المكتبة! يمكنك تقديم اقتراحات أو تحسينات عبر [GitHub](https://github.com/yourusername/ATM).

## الترخيص
هذه المكتبة مرخصة تحت **MIT License**. -->
ap2p 0.0.1
A simple peer-to-peer network using asyncio
Requires Python: >=3.4
Keywords: asyncio, networking, p2p, peer to peer

# ap2p

## Overview
`ap2p` is a package designed to facilitate peer-to-peer communication and data exchange. It provides a robust and efficient framework for building decentralized applications.

## Features
- No-nonsense API for peer-to-peer communication
- Asynchronicity with modern python3 async / await syntax
- Threading based on asyncio
- Ease of use with clear documentation and examples
- Easily extensible to accommodate various use cases

## Installation
To install the package, use the following command:
```bash
pip install ap2p
```

## Usage
Here's a basic example of how to use `ap2p` to start three interconnected nodes on localhost:
```python
from asyncio import create_task, gather, run
from ipaddress import ip_address

from ap2p import Address, Node


LOCALHOST = ip_address("127.0.0.1")

PEERS = [
    Address(LOCALHOST, 8000),
    Address(LOCALHOST, 8001),
    Address(LOCALHOST, 8002),
]


for peer in peers:
    node = Node(address=peer)
    create_task(node.start(peers=peers))
```
Global-Data-Interface 0.1.0a1
Global Data Interface is a Python package designed to provide a unified interface to easily query for data from a number of APIs providing international time series data.
Requires Python: >=3.6

# GLOBAL DATA INTERFACE

[![Version](https://img.shields.io/badge/version-0.1.0a1-orange)](https://github.com/EMCampbell01/Global-Data-Interface)

Global Data Interface is a Python package designed to provide a unified interface to easily query for data from a number of APIs providing international time series data.

---

## README Contents

- [Installation](#Installation)
- [Usage](#Usage)
- [Examples](#Examples)
- [Design](#design)

## Installation



---

## Usage

---

## Examples

---

## Design

### Global Data Interface

The `GlobalDataInterface` class is the main interface for the package. It is a singleton class. The `GlobalDataInterface` contains several sub-clients which each interact with and retrive data from their associated API. A `GlobalDataInterface` object can be used to interact with each of its internal sub-clients individually to create API specific requests and retrive API specific data.

The `GlobalDataInterface` has the following methods to retrive data from multiple sub-clients, and return data in a unified structure.

- `indicators()`
- `economies()`
- `indicator_groups()`
- `economy_groups()`
- `data()`

### Sub-Clients

In its current version `GlobalDataInterface` has 4 sub-clients for the following organizations and their APIs:

- `WBClient`
- `UNClient`
- `WTOClient`
- `IMFClient`

these all inheriate from the `BaseClient` abstract class. The `BaseClient` contains internal utility methods for url construction and making REST HTTP requests. The `BaseClient` contains an abstract method `info()` which is implemented in child classes to print details om the specific API being interacted with, including the organization providing it and a link to its documentation.

**World Bank Client**

The WB client provides methods for retreiving data from the WB V2 API endpoints.

- `indicators()`
- `economies()`
- `regions()`
- `topics()`
- `sources()`
- `income_levels()`
- `data()`

**World Trade Organization Client**

The WTO Client provides methods for retreving data from the WTO timeseries V1 API endpoints.

- `indicators()`
- `economies()`
- `indicator_catagories()`
- `regions()`
- `economic_groups()`
- `product_classifications()`
- `products_and_sectors()`
- `topics()`
- `units()`
- `periods()`
- `frequencies()`
- `data()`

**International Monetary Fund Client**

The IMF Client provides methods for retreving data from the IMF datamapper V1 API endpoints.

- `indicators()`
- `economies()`
- `regions()`
- `groups()`
- `data()`

**United Nations Client**

The UN Client is still to be implemented.

### Data-Structures
inferax 0.0.0
Statistical Inference with JAX.
Requires Python: <3.13,>=3.10

# inferax

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/inferax?color=blue&logo=Python&logoColor=white&style=for-the-badge)](https://pypi.org/project/inferax)
[![PyPI - Version](https://img.shields.io/pypi/v/inferax?color=blue&logo=PyPI&logoColor=white&style=for-the-badge)](https://pypi.org/project/inferax)
[![License: GPL v3](https://img.shields.io/github/license/wcxve/inferax?color=blue&logo=open-source-initiative&logoColor=white&style=for-the-badge)](https://www.gnu.org/licenses/gpl-3.0)<br>
[![Coverage Status](https://img.shields.io/codecov/c/github/wcxve/inferax?logo=Codecov&logoColor=white&style=for-the-badge)](https://app.codecov.io/github/wcxve/inferax)
[![Documentation Status](https://img.shields.io/readthedocs/inferax?logo=Read-the-Docs&logoColor=white&style=for-the-badge)](https://inferax.readthedocs.io/en/latest/?badge=latest)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install inferax
```

## License

`inferax` is distributed under the terms of the [GPL-3.0](https://www.gnu.org/licenses/gpl-3.0-standalone.html) license.