semvec/pypi-packages huggingface dataset:
twosenses 0.0.1
A simple python library to wish, listen and speak
Requires Python: >=3.6
Keywords: twosenses,Twosenses,twoSenses,TwoSenses,speaking,listening,wishing,python,python3,jarvis,siri,alexa,google assistant,voice,voice assistant,voice recognition,speech recognition,text to speech,speech to text,Gautam Yadav,Gautam,Yadav,gautamdiscoder

# Senses_2
Senses_2 is a python library which can give your python program the ability to speak and listen.
Senses_2 can also be used to greet the user.

## How to install this project
1. Open your terminal 
2. Type `pip install Senses_2` and hit enter

## How to use this project
   Use `.wish()` to wish good morning, good afternoon or good evening
   
   Use `.speak()` to speak
   
   Use `.listen()` to listen
   
## Example
```
import Senses_2
Senses_2.wish()
```

```
import Senses_2
Senses_2.speak()
```

```
import Senses_2
Senses_2.listen()
```
bbdl-test 0.0.1
BBDL
Requires Python: >=3.10

# BBDL

Downloads BorneoBulletin for offline reading.

## Usage

Can be used after importing

```py
from bbdl import BBDL
```

Then init an object and get a target date.

```py
app = BBDL()
year = "2023"
month = "09"
day = "18"
```

We need to identify how many pages the news has covered for that day.

```py
app.max_page_check(year, month, day)
```

This would store the value in the app object as `max_pages`

```py
print(app.max_pages) # E.g. 31
```

Lastly, call `bb_dl_full()` function. Set `download=False` to not download the pages. The pages will be stored in `data/BB-<YEAR><MONTH><DAY>` folder if `download=True` (default)

To view a list of image URLs it downloaded from, check its attribute `list_of_urls`

```py
print(app.list_of_urls)
```
playfairpolycipher 0.1
A Python library for the Playfair Cipher
Requires Python: >=3.6

```markdown
# Playfair Poly Cipher

Playfair Poly Cipher(Polyalphabetic Playfair cipher) is a Python library that provides tools for encrypting and decrypting text using the Playfair Cipher with a customizable key matrix.

## Installation

You can install Poly Playfair Cipher using pip:

```bash
pip install poly-playfair-cipher
```

## Example

### Encrypting Text

```python
from playfairpolycipher import PlayfairCipher

# Define a key for the Playfair Cipher
key = "KEYWORD"

# Initialize the PlayfairCipher with the key
cipher = PlayfairCipher(key)

# Encrypt a plaintext
plaintext = "HELLO WORLD"
ciphertext = cipher.encrypt(plaintext)
print("Ciphertext:", ciphertext)
```

### Decrypting Text

```python
from playfairpolycipher import PlayfairCipher

# Define a key for the Playfair Cipher
key = "KEYWORD"

# Initialize the PlayfairCipher with the key
cipher = PlayfairCipher(key)

# Decrypt a ciphertext
ciphertext = "ILIDGJZTJG"
plaintext = cipher.decrypt(ciphertext)
print("Decrypted Text:", plaintext)
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
```
python-notion-exporter 1.0.6
Export and download Notion pages asynchronously
Requires Python: >=3.6
Keywords: notion,notion-api,python_notion_exporter,notion-downloader,notion-py

# NotionExporter

## Description

`NotionExporter` is a Python class designed to simplify the process of exporting content from Notion. It provides an interface to configure, trigger, and download content exports from Notion. The class supports exporting content in various formats (Markdown, HTML, PDF) and also allows users to choose the scope of the export (current view vs. all content).

## Features

- Export content in **Markdown**, **HTML**, or **PDF** format.
- Configure the scope of your export: **current view** or **all content**.
- Option to include or exclude files in the export.
- Flatten the file tree structure upon export.
- Export multiple pages concurrently for faster processing.
- Monitor export progress with a progress bar.
- Automatically unpack zipped export files.

## Usage
1. **Download**:

   ```bash
   pip install python-notion-exporter
   ```


2. **Initialization**:

   ```python
   from python_notion_exporter import NotionExporter
   
   if __name__ == "__main__":
       exporter = NotionExporter(
           token_v2="YOUR_NOTION_TOKEN",
           file_token="YOUR_FILE_TOKEN",
           pages={"Page Name": "Page ID"},
           export_directory="path/to/save",
           flatten_export_file_tree=True,
           export_type=ExportType.MARKDOWN,
           current_view_export_type=ViewExportType.CURRENT_VIEW,
           include_files=True,
           recursive=True
       )
       exporter.process()
   ```

   You will need to get the `token_v2` and `file_token` values from your Notion cookies. The `pages` dictionary should contain pairs of `page_name: page_id` for each page you want to export.

## Needed Cookies

To export anything from Notion, one needs to authenticate oneself with some
Cookies (like a browser would). These cookies are called `token_v2` and
`file_token`. They are set on all requests of a logged in user when using the
Notion web-app.


### How to retrieve the Cookies?

- Go to [notion.so](https://notion.so).
- Log in with your account.
- Open the developer tools of your browser, open Application > Storage > Cookies
  (Chrome); Storage tab (Firefox).
- Copy the value of the Cookies called `token_v2` and `file_token` and paste
  them somewhere safe.
- ⚠️ If you don't find `file_token`, you need to have at least had exported a file manually once.
- Those cookies have a **1 year validity**, so you don't need to do this often.

2. **Process Exports**:

   ```python
   exporter.process()
   ```

   This will initiate the export, download, and unpacking processes for the pages defined.

## Requirements

- Python 3.6+

For more details or any issues, please raise a ticket or contact the maintainers.
pagecache-tools 1.0.0
Set of tools to monitor memory activity.

# pagecache_hit_miss


# Overview
This is a set of tools to monitor the memory used as pagecache.

For now it only has a tool which monitors the pagecache hit/miss

The idea is to add more tools, for example unify the pagecache_ttl (currently in an independent repo) 
https://github.com/sciclon2/pagecache_ttl


# Technical details
The cache hit and miss metric is gathered counting the kernel functions, following the Brendan Gregg idea 
https://www.brendangregg.com/blog/2014-12-31/linux-page-cache-hit-ratio.html

Using eBPF we track and cound the following Kernel functions:
* mark_page_accessed() for measuring cache accesses
* mark_buffer_dirty() for measuring cache writes
* add_to_page_cache_lru() for measuring page additions
* account_page_dirtied() for measuring page dirties


# Dependencies
This tool needs BCC, please follow the instructions bellow:
https://github.com/iovisor/bcc/blob/master/INSTALL.md


# Installation

Via pip:
```console
foo@bar:~# pip install pagecache_tools
```


Local in this repository root:
```console
foo@bar:~# pip install -e .
```

# Example


```console
foo@bar:~# /usr/local/bin/pagecache_hit_miss  --help
usage: pagecache_hit_miss [-h] [--interval-seconds INTERVAL_SECONDS]
                          [--daemon] [--send-metrics-to-dogstatsd]
                          [--log-level {INFO,DEBUG}] [--log-file LOG_FILE]

PageCache Hit/Miss

optional arguments:
  -h, --help            show this help message and exit
  --interval-seconds INTERVAL_SECONDS
                        Sets the interval to get the missed/hit values and
                        calculate the avg.
  --daemon              Execute the program in daemon mode.
  --send-metrics-to-dogstatsd
                        Send metrics to local DogStatsD
                        https://docs.datadoghq.com/developers/dogstatsd/
  --log-level {INFO,DEBUG}
                        Sets the log level
  --log-file LOG_FILE   Sets the log file.
```
libglvnd-egl-cos7-ppc64le 0.0.1
libglvnd-egl-cos7-ppc64le

# libglvnd-egl-cos7-ppc64le
libglvnd-egl-cos7-ppc64le - listed by Cycode to prevent dependency confusion.
Please contact us if you are the owner of this package.
research@cycode.com
logging-opentelemetry-format 0.0.3
opentelemetry formatter for python logging module.
Requires Python: >=3.6

# logging-opentelemetry-format

a simple logging formatter which can be used to format logs to opentelemetry specification coming out from a system.
it also provides some additional size control over log body and log attributes


#### Installation

- from pypi
```
pip install logging_opentelemetry_format
```

#### Usage
- check [example](tests/test_logging.py) for a complete example
- the formatter is available as
```
from logging_opentelemetry_format.utils import OpentelemetryLogFormatter
```
- on a basic level this formatter can be added to a logging handler
- it takes following optional keyword arguments
- `use_traces`: use the traces information to enrich logs or not(trace_id and span_id)
- `restrict_attributes_to`: list of attributes to which log's attributes should be restricted, any extra attributes passed inside extra keywords in logs will be added against `_meta` inside attributes.
- `meta_character_limit`: the max length of value for `_meta` in output logs' attributes, if the length of log's meta exceeds this limit the value of log's meta will be trimmed to specified length. also an attribute `_meta_original_length` is added with value as the length of original log meta and `_meta_too_large` with value `true` for debugging purpose.
- `body_character_limit`: the max length of value for log body, if the length of log body exceeds this limit the value of log body will be trimmed to specified value. also an attribute `_body_original_length` is added with value as the length of original log body and `_body_too_large` with value `true` for debugging purpose.
- `discard_attributes_from`: an array of attributes which needs to be skipped when exporting logs

#### Local development and testing

- build the docker-image of the package `docker-compose build --no-cache`
- run the image `docker-compose up`
- go to the container `docker exec -it loggingoplttester sh`
- to run tests  `pytest tests/` to run the actual tests.


#### License

- this project is licensed under [MIT License](LICENSE)