semvec/pypi-packages huggingface dataset:
yaast 0.1.5
AWS credentials MFA-Resolver tool
Requires Python: >=3.6

# Yaast (Jåst)

## YetAnotherAWSSessionTool

*Why?* ..After obtaining a normal accessKey set, 
the MFA enabled user faces the challege of 
mantaining a daily set of temp accessKeys+token (session) for
use with awscli, sdks and the stuff like terraform.

## 0. Setup "start" profile

    aws configure --profile awsops
    # PASTE keys from aws csv file ...
    
    vim ~/.aws/config 
    # ADD mfa_serial = arn:aws:iam::0000000:mfa/xxxxxxx

## 1. Execute

Writes a new [default] section into your $HOME/.aws/credentials,
after downloading a new SESSION temp access/token set through a "start" profile.
Start profile name defaults to [awsops] and should have 'mfa_serial' set, together with accesskeys.

Both the *start* and *dest* profiles names can be selected with flags

    yaast [-h] [flags] <mfacode>


*DEPENDS* on botocore
utf12 1.0.0
UTF-12 encoder
Requires Python: >=3.8

# utf-12
UTF-12 encoder based on [the tapemark article](https://web.archive.org/web/20230930121239/https://tapemark.narod.ru/comp/utf12en.html)

Original tapemark article: <https://tapemark.narod.ru/comp/utf12en.html>


Following the specs, everything is in big-endian.
Ensure that inputs are big-endian.

Encodes unicode characters 07c0-D7ff, e000-10ffff

## Install
    pip install utf12

## Usage


    from utf12 import encode, decode
    encoded_bytes = encode("R2-D2")
    print(decode(encoded_bytes))

### encode(unicode_characters)
unicode_characters is a python string of unicode characters
Returns a bytes object of the slabs with trailing 0 bits on the last byte if needed

### decode(slabs)
slabs is a bytes object of the slabs for the characters
Returns a python string of the unicode characters
pydocgenerator 0.0.4
A package for generating Docstring for python.
Requires Python: >=3.8

# DocGen-AI
DocGen-AI is a Python library that automatically generates docstrings for Python functions. It takes a Python file as input, generates docstrings for each function in the file, and outputs a new Python file with the generated docstrings.
# Features
 * Automatically generate docstrings for Python functions
 * Easy to use: just pass the file name to the DocGen instance and call the write_to_file() method
# Installation
You can install DocGen-AI by cloning the repository or using pip:

# Usage
Here’s a simple example of how to use DocGen-AI:
```python 
  from pydocgenerator import DocGen
  
  doc_gen = DocGen('./test.py')
  doc_gen.write_to_file()
```
In this example, DocGen is instantiated with the path to a Python file ('./test.py'). The write_to_file() method is then called to generate docstrings for each function in the file and output a new Python file with the generated docstrings.

# License
DocGen-AI is licensed under the MIT License. See the LICENSE file for more information.
pydcogenerator 0.1.0
A library for generating docstring for python programms.
Requires Python: >=3.8

# PyDocGenerator
PyDocGenerator is a Python library that automatically generates docstrings for Python functions. It takes a Python file as input, generates docstrings for each function in the file, and outputs a new Python file with the generated docstrings.
# Features
 * Automatically generate docstrings for Python functions
 * Easy to use: just pass the file name to the DocGen instance and call the write_to_file() method
# Installation
You can install PyDocGenerator by cloning the repository or using pip:
      git clone [<repository-url>](https://github.com/RijinRaju/PyDocGenerator/) 

## Dependencies
- **transformers**: A library for natural language processing using pre-trained models.
    pip install transformers

- **torch**: The PyTorch library for deep learning and neural networks.
    pip install torch

- **astunparse**: A Python library for parsing and un-parsing abstract syntax trees (ASTs).
    pip install astunparse
  


# Usage
Here’s a simple example of how to use DocGen-AI:
```python 
  from pydocgenerator.pydoc import PyDOC

  py_doc = PyDOC('./filename.py')
  py_doc.write_to_file()
```
In this example, DocGen is instantiated with the path to a Python file ('./filename.py'). The write_to_file() method is then called to generate docstrings for each function in the file and output a new Python file with docstrings attached.

# License
DocGen-AI is licensed under the MIT License. See the LICENSE file for more information.
fortimanager-template-sync 0.0.1.post1
FortiManager Template Sync
Requires Python: <4,>=3.9

# FortiManager GIT sync tool

This project aims to synchronize CLI templates from a GIT repository to FortiManager
via API calls automatically.

## Features

1. Test run
2. Check FW sync status before update
3. Error checking during update (rollback on error is supported by Workspace mode ADOMs)
4. Deploy changes to firewalls
5. CI/CD support

## Introduction

FMG by itself does not support GIT repository as backend to store CLI templates which
makes it hard to manage changes. Using GIT has many advances like tracking history, easy rollback to a version
in time. Additionally one could use GitHub to even manage developing these templates in a team with tools like
approval, review process, comments amongst others. Once the template changes are developed and approved, GIT can
merge the changes to its production branch which can trigger a run of this tool to sync up the changes to FMG.

This is beta software, do not use in production before testing!!

## Installation

This tool is intended to run via console or GIT runner with CI/CD.

Quick installation:
``` shell
pip install fortimanager-template-sync[rich]
```

[Quick Start Guide](https://realvitya.github.io/fortimanager-template-sync/user_guide/quickstart/) will do a quick
tour on setup but it is recommended to read the full documentation:
[User Guide/Installation](https://realvitya.github.io/fortimanager-template-sync/user_guide/installation/)
simply-log 0.2.6
A simple logging.txt library

# Text File Generation Module

This Python module provides a simple logging functionality, allowing users to generate text log files.

if not exist => create file.txt

```
- dir/
___ logFile.txt
___ logFile-1.txt
___ logFile-2.txt
```

coontent file :

```
[17/04/2024 09:56:05] [ERROR] this is a test message error dag
[17/04/2024 09:56:05] [INFO] this is a test info message index null
[17/04/2024 09:56:05] [WARNING] this is a test warning message scripte.py break
```

## Usage

Once installed, you can import the module into your Python script like this:

```python
from log import log_message

log_message("logFile", "error", "this is a test message")
```

### Additional Examples:

1. Logging an informational message:

   ```python
   log_message("logFile", "info", "this is an informational message")
   ```

2. Logging a warning message:

   ```python
   log_message("logFile-1", "warning", "this is a warning message")
   ```

3. Logging a debug message:

   ```python
   log_message("logFile-2", "debug", "this is a debug message")
   ```

4. Logging a critical message:

   ```python
   log_message("logFile", "critical", "this is a critical message")
   ```

5. Auto Log:

   ```python
   log_message("auto", "debug", "this is a debug message")
   # name file = %d%m%Y_%H%M%S.txt
   ```

[Cornelius Vincent @MIT @author ](https://www.linkedin.com/in/corneliusvincent)
ant-fin-agent-framework 0.0.2
AntFinAgentFramework is a framework for developing applications powered by multi-agent base on large language model.

# AntFinAgentFramework（AFAF）

## Overview
AntFinAgentFramework is a framework for developing applications powered by multi-agent base on large language model.  It provides all the essential components for building a single agent, and a multi-agent collaboration mechanism which  serves as a pattern factory that allowing developers to buid and customize multi-agent collaboration patterns. With this framework,  developers can easily construct multi-agent applications, and share the pattern practices from different technical  and business fields.

The framework will come with serveral pre-install multi-agent collaboration patterns which have been proven effective in real business scenarios, and will continue to be enriched in the future. Patterns that are currently about to be released include:

- PEER pattern：
This pattern utilizes four distinct agent roles: Plan, Execute, Express, and Review, to achieve a multi-step breakdown and sequential execution of a complex task. It also performs autonomous iteration based on evaluative feedback which enhancing performance in reasoning and analytical tasks. 


- DOE pattern：
This pattern consists of three agents: Data-fining agent, which is designed to solve data-intensive and high-computational-precision task; Opinion-inject agent, which combines the data results from first agent and the expert opinions which are pre-collected and structured; the third agent, Express agent generates the final result base on given document type and language style.

More patterns are coming soon...
botmom 1.0
Easiest and most variable module for creating telegram bots
Requires Python: >=3.6
Keywords: telegram botmom bots chatbots

# Botmom

Простая и многофункциональная библиотека для создания своих ботов для телеграмм


## Установка

Введите в терминал:

```bash
pip install botmom --upgrade --user
```

или запустите этот код:

```python
import os, sys

python = sys.executable
user = '--user' if 'venv' not in python and 'envs' not in python else ''
cmd = f'"{python}" -m pip install botmom --upgrade {user}'
os.system(cmd)
```


## Примеры

Простой echo-бот:

```python
from botmom import *

async def on_message(msg):
    await msg.answer("Твоё сообщение: " + msg.text)

run_bot("TOKEN_FROM_BOTFATHER")
```

Простой работа с командами:

```python
from botmom import *

async def on_command_start(cmd):
    await cmd.answer("Привет! \nДля помощи - напиши /help")


async def on_command_help(cmd):
    await cmd.answer("Пока ничем не могу помочь :(")


run_bot("TOKEN_FROM_BOTFATHER")
```

Создание Inline-кнопок

```python
from botmom import *

async def on_command_start(cmd):
    buttons = InlineButtons({"Да": "help_yes", "Нет": "help_no"})

    await cmd.answer("Привет! Тебе помочь?", buttons)


async def on_button(callback):
    if callback.data == "help_yes":
        await callback.answer("Тогда слушай внимательно!")

    elif callback.data == "help_no":
        msg = await callback.answer("Ну и ладно")
        
        await asyncio.sleep(3) # Вместо time.sleep(), время в секундах
        await msg.delete() # Удалит сообщение "Ну и ладно"
       

run_bot("TOKEN_FROM_BOTFATHER")
```


Создание Reply-кнопок

```python
from botmom import *

states = dict()

async def on_command_start(cmd):
    buttons = ReplyButtons(["Да", "Нет"])

    await cmd.answer("Привет! Тебе помочь?", buttons)
    states[cmd.chat_id] = "waiting"


async def on_message(msg):
    if states[cmd.chat_id] == "waiting" and msg.text == "Да":
        buttons = ReplyButtons(["Окей"])

        await msg.answer("Тогда слушай внимательно!", buttons)

    if states[cmd.chat_id] == "waiting" and msg.text == "Да":
        buttons = ReplyButtons() # Удалить все кнопки

        ok_msg = await msg.answer("Ну и ладно", buttons)

        await asyncio.sleep(3) # Вместо time.sleep(), время в секундах
        await ok_msg.delete() # Удалит сообщение "Ну и ладно"
        

run_bot("TOKEN_FROM_BOTFATHER")
```