semvec/pypi-packages huggingface dataset:
irdi-parser 1.0.1
A parser for International Registration Data Identifier (IRDI) strings.
Requires Python: >=3.6

The IRDI Parser is a Python program designed to parse IRDI (International Registration Data Identifier) strings based on the international standards ISO/IEC 11179-6, ISO 29002 and ISO/IEC 6523. It is used in the ECLASS standard. The program uses regular expressions to extract various components of an IRDI string and returns them in a structured format.
unacalc 1.0.3
Unacalc: A Unit-Aware Calculator
Requires Python: >=3.6

# Unacalc, the Unit-Aware Calculator

This project is a unit-aware calculator application developed using PyQt5 for the graphical user interface and Pint for handling units of measurement. It allows users to input and evaluate mathematical expressions that include units, providing accurate results with unit conversions.

## Features

- **Unit Management**: Supports unit conversions and arithmetic using the Pint library.
- **Expression Parsing**: Parses mathematical expressions, recognizing numbers, units, and operations using the Pyparsing library.
- **Arithmetic Operations**: Supports addition, subtraction, multiplication, division, and exponentiation.
- **Auto Calculation**: Automatically calculates and displays the result as the user types.
- **Unit Conversion**: Enables unit conversion within expressions using the "in" keyword (e.g., "100 m in cm").
- **Intuitive GUI**: Features an easy-to-use interface with an input field, result display, and a grid of buttons for input.
- **Error Handling**: Displays error messages for invalid expressions.
- **Keyboard Input**: Supports keyboard input for digits, operators, and backspace.
- **Date and Time Calculations**: Supports date and time arithmetic and conversion (e.g., "2024-11-13 + 2d", "now - 2 weeks").

## Getting Started

### Prerequisites

- Python 3.x
- PyQt5
- Pint
- NumPy
- Pyparsing

### Installation

1. Clone the repository:
    ```sh
    git clone https://github.com/tovam/unacalc
    ```
2. Change to the project directory:
    ```sh
    cd unacalc
    ```
3. Install the required packages:
    ```sh
    pip install -r requirements.txt
    ```

### Running the Calculator

To start the calculator application, run:
```sh
python unacalc.py
```

## Usage

- Enter mathematical expressions directly into the input field.
- Use the buttons to input numbers and operators.
- The result is automatically calculated and displayed in the result field.
- Use the "in" keyword to convert units (e.g., `100 m in cm`).

## Example Expressions

- `5 m + 3 m`
- `10 kg * 9.81 m/s^2`
- `100 W * 2 h in Wh`
- `100 m in cm`
- `1e3 kg * 9.81 m/s^2 in N`
- `2024-06-08T19:45:10 + 5 month`

## Contributing

Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.
simplememory 0.0.3
The framework for agent memory
Requires Python: >=3.10

# simplememory
This will be the memory of the agents and agency

**To use this package:**

Ensure that a `.env` exists with below parameters.

```
OPENAI_API_KEY=sk-"ADD YOUR API KEY HERE"
PINECONE_API_KEY = "ADD YOUR API KEY HERE"
PINECONE_INDEX="ADD YOUR INDEX NAME HERE"
```
If using entity memory or v1 of semantic memory, below parameters are needed
```
OPENAI_API_KEY = "ADD YOUR API KEY HERE"
NEO4J_URI = "ADD YOUR NEO4J URI HERE"
NEO4J_USERNAME = "ADD YOUR NEO4J USERNAME HERE"
NEO4J_PASSWORD = "ADD YOUR NEO4J PASSWORD"

```

**How to add to semantic memory:**
- use v1 of semantic memory which uses NEO4J
```
# Below version will be deprecated use v1
from memory.semantic_memory import SemanticMemory
if __name__=="__main__":
    sc= SemanticMemory()
    semantic_val,memory_item = sc.add_memory_item(mem_key="What is the capital of india?",mem_val="The capital of India is New Delhi"
    print(semantic_val)
    print(memory_item)

```
```python
# V1 of semantic memory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI
from memory.v1.semantic_memory_v1 import SemanticMemory

if __name__ == "__main__":
    llm = ChatOpenAI()
    sm = SemanticMemory()
    generation_prompt = ChatPromptTemplate.from_messages([
        (
            "system",
            "You will answer based on a question asked.",
        ),
        MessagesPlaceholder(variable_name="messages"), ])
    generate = generation_prompt | ChatOpenAI()
    while True:
        user_input = input("User: ")
        messages = generate.invoke({"messages": [user_input]})
        sm.add_memory_item(mem_key=user_input,
            mem_val=messages.content)
```

**How to retrieve semantic memory:**
- use V1 of sematic memory. It uses NEO4J.
```
# The below will be deprecated
from memory.semantic_memory import SemanticMemory
if __name__=="__main__":
    sc= SemanticMemory()
    result = sc.retrieve_memory_item(mem_key="what is the capital of India?")
    print(result['matches'][0]['metadata']['key'])
    print(result['matches'][0]['metadata']['value'])
    print(result['matches'][0]['score'])
```

```python
from memory.v1.semantic_memory_v1 import SemanticMemory

sm = SemanticMemory()
question = "What is blockchain?"
memory = sm.retrieve_memory_item(mem_key=question)
memory_key = memory[0]['name']
print(memory[0]['name'])
memory_value = sm.retrieve_memory_value(memory_key)
print(memory_value)
```


**How to add entity memory:**
```python
from memory.entity_memory import EntityMemory

if __name__=="__main__":
    sc= EntityMemory()
    sc.add_memory_item(mem_key="What is the capital of India?",mem_val="The capital of India is New Delhi")

```
py3-sdb 1.0.7
SDB is a simple database for beginners.
Requires Python: >=3.10

# Simple Database

SDB is a simple database for python.
If you're a beginner in python and want to save some stuff this is you're solution :)

SDB is using an id system to get specific data from
the database.

You'll find the documentation in the ```documentation.md```

###### DDavid701 <-> 2024 <-> v1.0.7
personal-punch-clock 1.0.0
A bare-bones command-line punch clock
Keywords: punch clock, time clock

# Personal Punch Clock
Personal Punch Clock is a bare-bones command-line punch clock.

## Installation
You must have Python 3.4 or newer installed.
Install the dependencies:
```shell
pip install -r requirements.txt
```
Rename the file `punch_clock.py` to `punch-clock`,
make it executable,
and copy it to a directory which your operating system searches
for executable files (e.g., `$HOME/bin`).


## Usage
Display your total work time and whether you are clocked in or out:
```shell
punch-clock
```

Punch in:
```shell
punch-clock --in
```

Punch out:
```shell
punch-clock --out
```

Delete the stored clock punches:
```shell
punch-clock --reset
```

## License
Personal Punch Clock is licensed under the Apache License, Version 2.0.