semvec/pypi-packages huggingface dataset:
RotatingTextFile 0.0.2
A ZERO dependency rotating file handler which rotates when YOU want it to, rather than based on bytes size.
Keywords: custom rotating file handler textfile logger

# Rotating Text File
A rotating file handler which rotates when YOU want it to, rather than based on bytes size. 

### When to use this module?
- When you have that niche case of logs being written into some text file from several functions and you just want it to rotate without having to re-write all the write calls with some new package.

### Why not use RotatingFileHandler provided by Python's logging module?
- If you are thinking of logging, please use RotatingFileHandler. It provides doRollover method which does the same functionality but with all the logging APIs.
- This module aims to solve cases of code where outputs were just being dumped into some file and over time the code grew so big that rotating the text file was needed without distrubing/refactoring the entire codebase.

### Installation
`pip install RotatingTextFile`

### Usage:
- Any existing code with text file can be replaced with the RotateTextFile constructor and a checker function.
- Eg:

If you have some code like:
```
with open("path/to/text/file","w") as fp:
  fp.write("some log")
```
All you have to do is:
```
def condition():
  return some_variable==0

with RotateTextFile("path/to/text/file",condition,10) as fp: #10 is backupCount as in RotatingFileHandler
  fp.write("some log")
``` 

- `condition` is called on every write. You can think of it as an analogy to a sort function which takes your `checking` function as an input.
- `RotateTextFile` inherits `io.TextIOWrapper`, so to pass any arguments specific to `io.TextIOWrapper`'s constructor, just pass them as Keyword Arguments.
- Since a file is rotated only on write, `RotateTextFile` constructor opens the file in `ab+` mode. Other supported modes are :`wb`. `mode` can be passed as:
`RotateTextFile("path/to/text/file",condition,10,'wb'):`
- `backupCount` indicates how many backups a file can have before it is rotated.
- Like `RotatingFileHandler` provided by Python's logging module, `RotateTextFile` guarentees that the file being written to will ALWAYS be `filename.log`
django-slappy 0.0.2
Run python in slack
Requires Python: >3.4

# django-slappy
[![PyPI version](https://badge.fury.io/py/vabbat.svg)](https://badge.fury.io/py/django-slappy)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/vabbat.svg)](https://pypi.python.org/pypi/django-slappy/)

This is a django app that allows you to run python interactively in slack. It requires an
existing server running django.

## Features

### Variable Persistence

![persist](https://raw.githubusercontent.com/Madoshakalaka/django-slappy/master/readme_assets/variable-persistence.png)

### Shared Scope
allows interactivity between users

![shared-scope](https://raw.githubusercontent.com/Madoshakalaka/django-slappy/master/readme_assets/shared_scope.png)

### Multi-liners

![multi-liner](https://raw.githubusercontent.com/Madoshakalaka/django-slappy/master/readme_assets/multi-liner.png)

### Fool Proof
Long running code will be terminated
![code-timeout](https://raw.githubusercontent.com/Madoshakalaka/django-slappy/master/readme_assets/timeout.png)

Exit prevention
![prevents-exit](https://raw.githubusercontent.com/Madoshakalaka/django-slappy/master/readme_assets/fool-proof.png)

## Installation

Need an already running django site

`pip install django-slappy`

1. Add "django_slappy" to your INSTALLED_APPS setting like this

    ```python
        INSTALLED_APPS = [
            ...
            'django_slappy',
        ]
    ```

2. Include the URLconf in your project urls.py like this

```
    path('slappy/', include('django_slappy.urls'))
```

3. [Create a slack app](https://api.slack.com/) and add command with url 'http://your-server/slappy/'

4. Install to workspace. Slack will give you an OAUTH secret. Paste to your `settings.py` like
following

    ```
    SLACK_OAUTH_SECRET = "abab-1231231231232-sfasfasdf-12312312"
    ```
   A better practice is to use environment variable.
   
## Note

Of course you'll expose your server to remote-exploitation.

Make sure your have nice people in your workspace, otherwise prepare to get your entire server deleted
simisimi 0.0.3
NPL Package in development
Requires Python: >=3.6
Keywords: NLP corpus meaning

# CID SimilarityLab

El primer paquete de NLP desarrollador por el **Centro de Inteligencia Digital**. La clase implementada les permitira interactuar con los modelos de lenguaje generados a partir de dos grande corpus. **The Guardian** y **The New York Times** fueron las grandes fuentes informaciÃ³n para llevar a acabo este proyecto.

Pueden encontrar toda la documentaciÃ³n [aquÃ­](https://cid-docs.readthedocs.io).
sejong-downloader 1.0.0
Downloader for Sejong corpus

# sejong-downloader

[![PyPi](https://img.shields.io/pypi/v/sejong-downloader)](https://pypi.org/project/sejong-downloader/)

세종 코퍼스를 다운로드하기 위해 사용하는 다운로더입니다.

## 사용법

```shell
$ pip install sejong-downloader
$ # 특정한 경로에 다운받을 경우, p 옵션을 주시기 바랍니다.
$ # 기본값은 ./data 입니다.
$ sejong-downloader -p data
```
webcandy 0.0.2
API and web interface for Fadecandy

<img src="https://raw.githubusercontent.com/gcpreston/webcandy/master/webcandy/static/img/webcandy_logo.png" alt="Webcandy" width="500" height="85">

API and web interface for Fadecandy control. For the client-side code
responsible for receiving requests from the Webcandy server and running lighting
configurations on the Fadecandy itself, see
[webcandy-client](https://github.com/gcpreston/webcandy-client).

![](https://s3.gifyu.com/images/webcandy_demo1.gif)
![](https://s3.gifyu.com/images/webcandy_demo2.gif)

##  Requirements
- [Python 3.7+](https://www.python.org/downloads/)
- [Node.js + npm](https://nodejs.org/en/download/)

## Setup
To install the necessary node modules, run:
```
$ cd webcandy/static
$ npm install
```

### virtualenv
It is recommended to use a virtual Python environment. To set up virtualenv, run
the following:
```
$ pip install virtualenv
$ virtualenv venv
```
The virtual environment is now created. **To use it, it must be activated like
so**:
- Windows: `> .\venv\Scripts\activate`
- Mac/Linux: `$ source ./venv/bin/activate`

Then, install the project requirements:
```
(venv) $ pip install -r requirements.txt
```

## Running
### Dev environment
In a development environment, Webcandy should be run using Flask:
```
(venv) $ flask run
```

Then, in a different terminal:
```
webcandy/webcandy/static $ npm run watch
```
This will watch for front-end changes and automatically rebuild the JavaScript.

* **Note**: If you don't see your changes in the browser, use `Ctrl/Cmd+Shift+R`
to refresh and clear cache.

### Server environment
To run Webcandy from a local server, activate the virtual environment and run
the server using `gunicorn`:
```
(venv) $ gunicorn 'webcandy:create_app()'
```

To build the front-end code, run:
```
webcandy/webcandy/static $ npm run build
```

### Clients
To control LEDs, you will need to connect a
[client]((http://github.com/gcpreston/webcandy-client))
([docs](https://webcandy.readthedocs.io/en/latest/client/quickstart.html)).

```
$ pip install webcandy-client
$ wc-client RGBLover573 password123 MyClient
```

###  Login
On an independant server, if you want a user with some example data saved you
can log in as "testuser1" or "testuser2", each with password "Webcandy1".

## Documentation
Documentation can be found at https://webcandy.readthedocs.io/. (WIP)

## Acknowledgements
* Thanks to Maksim Surguy ([msurguy](https://github.com/msurguy)) for the awesome logo!
geoparquet 0.0.3
GeoPandas API for Parquet file format.

# GeoParquet

GeoParquet for Python is a GeoPandas API designed to facilitate fast
input/output of GIS data in the open source Parquet file format.

The project is currently a proof of concept.

__Why is this project needed?__

The GIS community currently lacks a fast, efficient, open-source file format for
persisting and sharing data with. The purpose of the GeoParquet project is to
develop such a file format.

__How does it work?__

The GeoParquet file format is simple adaptation of the existing Parquet file
format: geometries are stored as well-known binary (WKB), and the coordinate
reference system is stored as a WKT string (specifically WKT2_2018) in the
file's metadata.

__Basic usage__

```python
import geopandas as gpd
import geoparquet as gpq

# read in file from shapefile or other format using geopandas
gdf = gpd.read_file('example file.shp')

# call .to_geoparquet() method on geopandas GeoDataFrame to write to file
gdf.to_geoparquet('example file.geoparquet')

# read from file by calling gpq.read_geoparquet() function
gdf = gpq.read_geoparquet('example file.geoparquet')
```
andesite.py 0.2.4
Andesite client for Python
Requires Python: ~=3.7

# andesite.py
[![CircleCI](https://circleci.com/gh/gieseladev/andesite.py.svg?style=svg)](https://circleci.com/gh/gieseladev/andesite.py)
[![GitHub release](https://img.shields.io/github/tag/gieseladev/andesite.py.svg)](https://github.com/gieseladev/andesite.py/releases/latest)
[![PyPI](https://img.shields.io/pypi/v/andesite.py.svg)](https://pypi.org/project/andesite.py)

A Python client library for [Andesite](https://github.com/natanbc/andesite-node).
andesite.py tries to be as flexible as possible while still providing the same,
consistent API.
The library comes with built-in support for [discord.py](https://github.com/Rapptz/discord.py),
but it can be used with any library of your choice.

## The goodies
- Pythonic, fully typed API including all Andesite "entities"
- Client pools with balancing and even state migration. If one node goes down
its players are seamlessly migrated to another one.
- Custom state handlers. andesite.py doesn't force you to use its state manager,
not even for the client pools. It provides you with a solid in-memory one, but
you can swap it out however you want.
- Future-proof design so that if the library becomes outdated it still remains
usable.

## Installation
You can install the library from PyPI using pip:
```shell
pip install andesite.py
```

## Look & Feel
The following is a small example of how to use andesite.py. For more
in-depth examples and information, please refer to the documentation.

Please keep in mind that the following example is incomplete. It only
serves to demonstrate some andesite.py code.

```python
import asyncio

import andesite


client = andesite.create_client(
    "http://localhost:5000",            # REST endpoint
    "ws://localhost:5000/websocket",    # WebSocket endpoint
    None,                               # Andesite password
    549905730099216384,                 # Bot's user id
)

async def main() -> None:
    result = await client.search_tracks("your favourite song")
    track_info = result.get_selected_track()

    # notice that we haven't called any sort of connect method. You can
    # of course manually connect the client, but if you don't, that's no
    # biggie because andesite.py will do it for you.
    await client.play(track_info.track)

asyncio.run(main())
```

## Documentation
You can find the documentation on the project's website.
[Click here](https://giesela.dev/andesite/) to open the
documentation.

You can also take a look at the [examples](examples) directory
for a reference.


## Alternatives
If andesite.py isn't what you're looking for, first of all, please
leave some feedback, but secondly here are some alternative Python client
libraries which you can use:

- [granitepy](https://github.com/twitch0001/granitepy)