semvec/pypi-packages huggingface dataset:
LeBotTel 0.4.0
A simple Telegram Bot
Requires Python: >=3.10

![Logo](https://raw.githubusercontent.com/tobiweisss/LeBotTel/main/images/logo_text_inv.png#gh-dark-mode-only)
![Logo](https://raw.githubusercontent.com/tobiweisss/LeBotTel/main/images/logo_text.png#gh-light-mode-only)
## Abstract
LeBotTel is an easy to use python package to create your own Telegram bots for different use cases. For details how to use this package refer to the [quick start](#quick-start) section. 

## Name
The name LeBotTel is combined from "LeCun", "RoBot" and "Telegram". The "Le" in the name comes from Yann LeCun, to honor his work on neural networks (has nothing to do with this project, but he is a great scientist and pioneer in the field of neural networks (LeNet)). What has this bot to do with neural networks? We want to use this bot to log the training of neural networks. "Bot" comes from RoBot, because this is what the goal of this project is. And "Tel" comes from Telegram, because its a bot for Telegram. The "Pi" in our logo represents looks similar to the "tT" in "LeBotTel" and stands for the used Programming Language Python.

## Quick Start
TODO add quick start / API documentation / how to install / ...

## Changelog
- 0.1.0: setup package. Bot can send messages and images
- 0.2.0: Bot can receive messages 
- 0.3.0: Add method `export_config` to save the current token and chat_id to a file, add classmethod `from_config` to create a bot from the config file, add classmethod `from_env` to create a bot from the environment variables `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID`. Methods `import_chat_id` and `export_chat_id` are deprecated and will be removed in version 1.0.0
- 0.3.1: Adapting package structure 
- 0.4.0: Add `send_gif` method

## Authors
- Antonio Vidos
- Tobias Lettner
- Tobias Weiß
- Uwe Kölbel
marianodoc 1.0.13
Produce WORD and PDF files with great ease, examples provided on import
Keywords: MS WORD,PDF,Word

With Mariano Doc, its easy to insert lines of texts into a WORD or PDF file. <br>Allows for different color font color and sizes. <br>For Word files only there is options for Headings sizes and listing items with bullets.<br><br>Sample Code:<br><br>import marianodoc as md <br>doc=md.new_doc()<br>doc.insert_line("sample line1")<br>doc.insert_line("sample line2")<br>doc.insert_line("sample line3")<br>doc.createPDFFile("some_name.pdf")<br>doc.createWordFile("some_name.docx")<br><br><br><br>Note there are more features such as headings color fonts,highlighting, for more detail<br>doc.show_example1()<br>doc.show_example2()<br><br>If you like this library checkout my other library "MarianoInput" for getting user input<br><a href="https://pypi.org/project/marianoinput/">MarianoInput</a><br><br>For help or feedback email marianoricoPy@gmail.com
openai-pricing-calc-draft 0.5.0
LLM Cost Calculation
Keywords: python,video,stream,video stream,camera stream,sockets


# OPEN AI API - PRICE CALCULATOR

## Overview
This package is created to calculate cost of OPEN AI API usage.

Pricing based on following url : [OPEN AI Pricing API](https://openai-api-pricing-web-api.onrender.com/openai).
Source code: [Github](https://github.com/kokenconsulting/openai-api-pricing)



## Usage

### Installation

Install Page
```
pip install openai-pricing-calc-draft
```


### Without Surrounding Code

```python
from lll_pricing_calculation import calculate_openai_pricing

# Without surrounding Code
costForThousandCurrency,embeddingsCost,promptCost,completionTokenCost,total_cost = calculate_openai_pricing("GPT-3.5 Turbo","4K context",token_counter.total_embedding_token_count,token_counter.prompt_llm_token_count,token_counter.completion_llm_token_count)
print("currency:"+costForThousandCurrency)
print("embeddingsCost:"+str(embeddingsCost))
print("promptCost:"+str(promptCost))
print("completionTokenCost:"+str(completionTokenCost))
print("total cost:"+str(total_cost))
```
### With Surrounding Code Using Llama Index
```python
import tiktoken
from llama_index.callbacks import CallbackManager, TokenCountingHandler
from llama_index import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
from lll_pricing_calculation import calculate_openai_pricing

sampleQuery = "Sample Query"
token_counter = TokenCountingHandler(
    tokenizer=tiktoken.encoding_for_model("text-davinci-003").encode,
    verbose=False  # set to true to see usage printed to the console
)
callback_manager = CallbackManager([token_counter])
service_context = ServiceContext.from_defaults(callback_manager=callback_manager)

def askQuestion(quest,storage,service_context,token_counter):
    token_counter.reset_counts()
    # index defined outside
    specificindex = index.get_index(dataFolder,"./storage"+storage,service_context)
    print(quest)
    result = query.query_index(specificindex, quest,"./storage"+storage)
    print(result)
    # otherwise, you can access the count directly
    print("Embeddings Token Counter stuff is below (total_embedding_token_count):")
    print(token_counter.total_embedding_token_count)
    print("Detailed ")
    print('Embedding Tokens: ', token_counter.total_embedding_token_count, '\n',
      'LLM Prompt Tokens: ', token_counter.prompt_llm_token_count, '\n',
      'LLM Completion Tokens: ', token_counter.completion_llm_token_count, '\n',
      'Total LLM Token Count: ', token_counter.total_llm_token_count)

    # CALCULATE PRICING TAKES PLACE HERE
    costForThousandCurrency,embeddingsCost,promptCost,completionTokenCost,total_cost = calculate_openai_pricing("GPT-3.5 Turbo","4K context",token_counter.total_embedding_token_count,token_counter.prompt_llm_token_count,token_counter.completion_llm_token_count)
    print("currency:"+costForThousandCurrency)
    print("embeddingsCost:"+str(embeddingsCost))
    print("promptCost:"+str(promptCost))
    print("completionTokenCost:"+str(completionTokenCost))
    print("total cost:"+str(total_cost))

askQuestion(sampleQuery,"4",service_context,token_counter)
```
jipdate 2.0.3
Command line tool for Jira
Requires Python: >=3.6

# Jipdate - Jira comment and status update tool

Jipdate is a tool used at Linaro that makes it possible in one go to:

* Update all tickets belonging to a certain user using command line and your
  favorite editor.
* Create (and save) a status report.
* Move Jira tickets into different states (To Do, In Progess etc.).
* Send status reports using email.

For all instructions (install, how to use, examples etc), please visit
https://jipdate.readthedocs.io.
calculator-JN 1.0.0
A small calculator package
Requires Python: >=3.8

# Calculator
## Overview
This Calculator is a simple Python class designed to perform basic arithmetic operations including addition, subtraction, multiplication, and division. It can also calculates the n-th root of a number and reset the current result.
## Features
- Basic Arithmetic Operations: Perform addition, subtraction, multiplication, and division.
- N-th Root Calculation: Calculate the n-th root of the current result.
- Reset Memory: Calculator has its own memory and it manipulates its starting number 0 until it is reset.
- Input Validation: Validates all inputs to ensure they are numeric.
- Error Handling: Handles division by zero and invalid root calculations.
## Installation
This package has been uploaded on PyPI and you can install it using pip
```
pip install calculator-JN
```
## Usage
### Initialization
Create an instance of the Calculator class:
```
from calculator import Calculator
calc = Calculator()
```

### Performing Operations
You can perform arithmetic operations as follows:
```
result = calc.add(5)
result = calc.subtract(2)
result = calc.multiply(3)
result = calc.divide(4)
result = calc.n_root(2)
```
### Resetting the Calculator
Reset the calculator to its initial state:
```
calc.reset()
```
## Requirements
Python 3.x
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.