semvec/pypi-packages huggingface dataset:
hello-world-prod-vk-2 0.2.1
A Hello World package for testing publishing
Requires Python: >=3.6

This is a simple exercise to publish a package onto PyPi.

Projects using Setuptools 0.6.27+ have standard readme files (README.rst, README.txt, or README) included in source distributions by default. The built-in distutils library adopts this behavior beginning in Python 3.7. Additionally, Setuptools 36.4.0+ will include a README.md if found. If you are using setuptools, you donâ€™t need to list your readme file in MANIFEST.in. Otherwise, include it to be explicit.
toansttlib 2.11.0
A tool package
Requires Python: >=3.6

## Introduction
This is toanstt's library\
Repository: https://github.com/nmtoan91/pytoansttlib \
Pypi repo: https://pypi.org/project/toansttlib/



## TChart usage example

```python
from toansttlib import *
import pandas as pd
import os
import matplotlib.pyplot as plt
import numpy as np
import shutil
#datasetIds = ['Cafe_Chatbot','Dialog','Emotions_MultiTurnDiag','Question_Answer_1','Question_Answer_2','Question_Answer_3','WikiQA']
datasetIds = ['Dialog','Emotions_MultiTurnDiag','Question_Answer_1','Question_Answer_2','Question_Answer_3','WikiQA']

#params = { "text.usetex" : True,"font.family" : "serif", "font.serif" : ["Computer Modern Serif"]}
params = { "text.usetex" : False,"font.family" : "serif"}
plt.rcParams.update(params)
fig, axs = plt.subplots(1,2, figsize=(8, 4))


fig.tight_layout(pad=2.0)
fig.subplots_adjust(bottom=0.3)
ys = []
ys_time=[]
for i in range(6):
    data = pd.read_csv('./FigureDraw/TESTING_epoch/training__home_nmtoan_DATA_CHATBOT_'+datasetIds[i]+'_glue_.csv')
    x = data.epoch.to_numpy()
    y = data.train_loss.to_numpy()
    ys.append(y)
    ys_time.append(data.train_time.to_numpy())
fmta(-1)
DrawSubFigure_SimpleLine(axs[0],x,ys,x_title='epochs',y_title='Loss')
fmta(-1)
DrawSubFigure_SimpleLine(axs[1],x,ys_time,x_title='epochs',y_title='Training time (seconds)')

axs[0].legend(datasetIds,ncol=3,bbox_to_anchor=(1.6, -0.65, 0.5, 0.5))


fileName = './FigureDraw/'+os.path.basename(__file__).replace(".py",".pdf")
fileName2 = "C:/Users/nmtoa/Dropbox/Apps/Overleaf/Toan_ContextBasedFineTuneGPT2/Figures/" + os.path.basename(__file__).replace(".py",".pdf")
plt.savefig(fileName)
shutil.copyfile(fileName,fileName2 )

plt.show()
```


## TChart usage example
```python
from toansttlib import TCSVResult
result = TCSVResult('stage3')
result.Add('Dataset', datasetID)
result.WriteResultToCSV(folder="RESULT/stage3")
```
usingversion 0.1.2
A package to make it easy for other packages to report their version.
Requires Python: >=3.9,<4.0

usingversion
============

`usingversion` is a package designed to help
other packages help their users keep tract of 
what version they are using.

It was built with packages that are maintained with
[poetry](https://github.com/python-poetry/poetry) in
mind but it works in a more limited way with other
approaches.

What is the Problem?
--------------------

As developers, we would like to have a single source or truth for
the version number of packages we maintain. In projects that use
[poetry](https://github.com/python-poetry/poetry), 
this is a `pyproject.toml` file, which typically begins 
something like

```
[tool.poetry]
name = "mypackage"
version = "1.2.3"
...
```

Once I have put a version number there, I would like the
code

```python
import mypackage

myppackage.version
```

to return the version number from `pyproject.toml`.

The issue is that project versions go through different
lifecycle phases. A package that has been built and published
on [pypi](https://www.pypi.org) has the version number that
started in `pyproject.toml` when it was built encoded elsewhere.
But a newer version that I am actively developing, testing, or debugging
before release only has the `pyproject.toml` version.

`usingversion` knows about this, and knows how to find the version
in either of those places in different scenarios. It makes 
`mypackage.version` always work no matter how I am using or developing
or testing.

### What about the `+`

As an added measure, to reduce confusion between development and 
production environments, when the version number comes straight
from `pyproject.toml` in a development environment, a `+` is 
appended. This indicates that the source could have been modified
in the development environment. So instead of `"1.2.3"`, the
version will be reported as `"1.2.3+"`.

For Package Maintainers
-----------------------

To use `usingversion` in your package, first take
a dependency on `usingversion`. In Poetry, you would
do this with 

```shell
poetry add usingversion
```

In other environments, you might add it to e.g. 
`requirements.txt.`

Now, just
add the following to the very end of your top-level `__init__.py`:

```python
from usingversion import getattr_with_version

__getattr__ = getattr_with_version("mypackage", __file__, __name__)
```

Be sure to substitute the actual name of your package for 
`"mypackage"`.

To test, try

```python
import mypackage

print(f"The version of mypackage is {mypackage.version}.")
```

For End Users
-------------

There's really nothing all that exciting to do.
You might not even know or care that the developer
of a package you depend on chose to use `usingversion`.
If a package `somepackage` that you depend on uses
`usingversion` then you can check the version with

```python
import somepackage

print(f"The version of somepackage is {somepackage.version}.")
```

Unless the maintainters of `somepackage` have chosen
otherwise, `somepackage._version` is the same as 
`somepackage.version` so you can use whichever you
prefer.
rediscollectiondb 0.1.2
A simple interface to manage collections in Redis.
Requires Python: >=3.6


# RedisCollectionDB

## Description
RedisCollectionDB is a Python library that provides an easy-to-use interface for managing collections and items within a Redis database. It allows for the addition and removal of collections and items, listing of current collections and items, and subscribes to changes in collections and items via Redis' publish/subscribe mechanism.

## Installation
Install RedisCollectionDB using pip:

```bash
pip install rediscollectiondb
```

## How to Use
First, ensure you have Redis running on your local machine or a server.

```python
from rediscollectiondb import RedisDB

# Initialize the RedisDB instance
db = RedisDB(db_name='your_database_name')

# Add a collection
db.add_collection('books')

# Add items to the collection
db.add_item('books', 'The Great Gatsby')
db.add_item('books', '1984')

# List collections
print(db.list_collections())

# List items in a collection
print(db.list_items('books'))

# Remove an item
db.remove_item('books', '1984')

# Remove a collection
db.remove_collection('books')
```

## Handling Events with Callbacks
You can extend the `RedisDB` class to handle item and collection changes by overriding the `on_item_changed` and `on_collection_changed` methods. Here's an example:

```python
class MyRedisDB(RedisDB):
    def on_item_changed(self, action, collection, item):
        print(f"Custom handling for item: {item} in collection: {collection}, action: {action}")

    def on_collection_changed(self, action, collection):
        print(f"Custom handling for collection: {collection}, action: {action}")

# Use the subclass with custom event handling
db = MyRedisDB(db_name='myapp')

# Now, adding or removing items and collections will trigger custom handling
db.add_collection('movies')
db.add_item('movies', 'Inception')
```

## Example
This example demonstrates adding a collection, adding items to it, and then listing and removing items and the collection, with custom event handling for changes.

```python
if __name__ == '__main__':
    db = MyRedisDB(db_name='myapp')

    db.add_collection('books')
    db.add_item('books', 'The Great Gatsby')
    db.add_item('books', '1984')

    print("Collections:", db.list_collections())
    print("Books items:", db.list_items('books'))

    db.remove_item('books', '1984')
    print("Books items after removal:", db.list_items('books'))

    db.remove_collection('books')
    print("Collections after removing books:", db.list_collections())
```
pages2pdf 0.0.16
Converts .pages to .pdf
Requires Python: >=3.8

# pages2pdf

**IMPORTANT**: You need your own Cloudconvert API Key to use this tool. You can get one for free at [cloudconvert.com](https://cloudconvert.com/).
Not affiliated.

## Quickstart
1. Add your Cloudconvert API Key to .env:
```shell 
CLOUDCONVERT_API_KEY="ERTGIZTDIFGKDRztgITZdfGkzuf5i66tzfkVt6RFitzkujhgo67rtzfghT6rfiutzk"
```


2. Convert all .pages files in the directory and its subdirectories to .pdf:

```shell
python3 -m pages2pdf .
```


## More
Get help
```shell
python3 -m pages2pdf --help
```