semvec/pypi-packages huggingface dataset:
functional-list 0.1.6
package for map a list
Requires Python: >=3.6

# Easy Map Reduce for a list python:
## Description
This library was created to allow us to use functional style in a list object
in python. It is easier to use functional style when we have for example to deal with a several 
transformation in our data. 

In this little library, we can find most of the function used in a list object but with map
or reduce or flatten,... methods. If you are familiar with spark rdd,
the behavior of all the methods  created in ListMapper object is mostly the same. The difference is that it includes some properties of a python list.

## News
Now a doc-string was added to this package, so you can use it 
and have some example of how to use a method in the object
created with ListMapper

## Issues:
This Library work only with __python version >=3.6__.
If you attempt to use it with an anterior version, there will be
an error occurred in some methods.

## How to use this package:
First install this package with pip by doing:
```
pip install functional-list
```
Then, you can import ListMapper to create an object:
```
from functional_list import ListMapper
``` 
## Example:
Let's make the famous word count with this package.
Suppose one have a list of a document comes from a text file, 
and we load it in a simple list
```
document =[
            "python is good",
            "python is better than x",
            "python is the best",
            ]

## Now, let tranform the list to a list mapper 
document = ListMapper[str](*document)

res = document.flat_map(lambda x:x.split())\
              .map(lambda x:(x,1))\
              .reduce_by_key(lambda x,y:x+y)

## result will be:
#List[('than', 1), ('the', 1), ('best', 1),
#        ('better', 1), ('good', 1), ('is', 3), 
#        ('python', 3), ('x', 1)]
# And you have your word count :)
```
The ListMapper object has also the same behavior as a standard
python list.
```
my_list = ListMapper[int](2, 4, 9, 13, 15, 20)
## Append element 
my_list.append(55)
## will give List[2, 4, 9, 13, 15, 20, 55]
## Let make some ordianry transformation
my_list.map(lambda x: x*x)\
       .filter(lambda x:x%2==0)\
       .reduce(lambda x,y:x+y)

# Give as a result 420

```
If you want to get the list of the method in this object,
you just have to do the next command in python:
```
dir(ListMapper)
```
To get the doc-string of a method:
```
print(my_list.map.__doc__)
```
In each, method, there is an example of how to use the method.
tf-lazy-loader 0.1.1
Lazy loading of Python modules, based on TensorFlow's LazyLoader util.
Requires Python: >=3.10,<4.0

# tf-lazy-loader


## Installation

```bash
pip install tf-lazy-loader
```

## Usage

```python
from tf_lazy_loader import dynamic_import

# Lazily import the "os" module
os = dynamic_import("os")

# Trigger the actual import by referencing a name in the "os" module:
print(os.environ)
```

### Conditionally switching between lazy and eager imports

You can set the `lazy` arg of the `dynamic_import` function to `False` to eagerly import the given module. This can be useful if you only want to perform lazy imports based on a flag.

For example, if you have a Django project and you only want to enable lazy imports when in DEBUG mode, and do imports eagerly in production, you would do something like this:

```python
from django.conf import settings

DEBUG = settings.DEBUG

os = dynamic_import("os", lazy=DEBUG)
```
slack-notification 0.1.8
A simple way to send slack notification
Requires Python: >=3.9
Keywords: monitoring,notification,observability,slack,telemetry

# Slack-Notification
A simple way to send slack notification

## Install
```
pip install -i slack-notification
```

## Usage
```python
from slack_notification.slack_notification import SlackNotification

CHANNEL = "YOUR_CHANNEL" #example TXXXXXXXXXX/BXXXXXXXX/NXXXXXXXXXX"
slack = SlackNotification(CHANNEL)
message = "YOUR_MESSAGE"
response = slack.notify(message)
```
vt100logging 1.1.0
VT100 logging for Python
Requires Python: >=3.8

# vt100logging

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

![example log feed](https://raw.githubusercontent.com/g2labs-grzegorz-grzeda/vt100logging/main/res/screenshot.png)

The original `logging` package lacks basic coloring of the log output. This does not help when one tries to quickly check on the real time console feed.

`vt100logging` is a simple wrapper around `logging`. Using [VT100 escape](https://www.wikiwand.com/en/ANSI_escape_code#Colors) codes it colors the log feed.

## Supported OS
Tested on MS Win11 and Ubuntu.

## Installation
`pip install -U vt100logging`

## How to use it
Simple use case
```python
from vt100logging import vt100logging_init, D, I, W, E

vt100logging_init('LOGGED-MODULE', is_verbose=True)

D('example DEBUG message')
I('example INFO message')
W('example WARNING message')
E('example ERROR message')
```

Extract more information from exception
```python
from vt100logging import EX

...
except Exception as e:
    EX(e)
...
```

Store log into file on the side:
```python

from vt100logging import vt100logging_init, I

vt100logging_init('my-module', store_to_log_file=True)

I("Logging both to console AND log file")

```

## Contribution
If something is wrong, you can raise issues [here](https://github.com/g2labs-grzegorz-grzeda/vt100logging/issues).

## Copyright
Created by Grzegorz Grzęda. Distributed under MIT license