semvec/pypi-packages huggingface dataset:
pybyte 0.1.8
Byte API Wrapper for Python
License: MIT
Requires Python: >=3.6.0


![pybyte-logo](images/logo.svg)

*** 

# A Python wrapper for the byte.co app.
Python 3.6+ Required.
***
**Attention**: This project was built in a weekend (mostly in the weekend that it was launched) as such this is **not production level** software. 

Byte **does not** have an official web API for developers, and most likely this will violate the ToS. Endpoints were found from the mobile app. As such, this wrapper can break at anytime. Do not rely on this wrapper.
***


# Installation
- PyPi (Recommended)
    ```
    pip install pybyte
    ```
- Git repo
    ```
    git clone https://github.com/ms7m/py-byte
    cd py-byte
    python3 setup.py install
    ```

# Usage

```python
>>> import pybyte
>>> 
>>> byte = pybyte.Byte("7WMRREHUQRH4DBK7DQCV7YWL44")
>>> 
>>> byte.me().username
'BotBottyFace220'
>>> 
>>> my_timeline = byte.me().timeline()
>>> 
>>> # no rate limit protection yet. do it at your own risk!
... 
>>> import time
>>> 
>>> for post in my_timeline.feed:
...     print(f"Caption: {post.caption}")
...     time.sleep(1)
...     print(f"Author: {post.author.username}")
...     print('\n')
... 
Caption: 
Author: BotMcBotFace2300


Caption: Nice
Author: BotMcBotFace2300


Caption: 
Author: BotMcBotFace2300


Caption: 
Author: BotMcBotFace2300


Caption: @peaks 
Author: BotMcBotFace2300
# ...
>>> 
>>> 
>>> # Set your own username
... 
>>> byte.me().username = "BotMcBotFace2300"
>>> byte.me().username
'BotMcBotFace2300'
>>> 
>>> # Get Posts
... 
>>> post = byte.get_post("4ZPUKLE5OZB7JJGIBLVMIYQLBU")
>>> post.caption
'@peaks '
>>> post.mentions
[<pybyte.user.ByteUser object at 0x10b33b550>]
>>> 
>>> # rebyte / like posts
... 
>>> post.rebyte()
True
>>> post.like()
True
>>> 
>>> # comment posts
... 
>>> post.comment("Haha!")
True
>>> 
>>> # Upload Posts
... 
>> byte.upload('sample.mp4', caption="haha too funny!")
>> # Automatically generate a thumbnail
>> byte.upload('sample.mp4', caption="haha too funny!", generate_thumbnail=True)
>> # Supply your own thumbnail!
>> byte.upload('sample.mp4', caption="haha too funny", providedThumbnail="ultraCoolthumbnail.jpg")

```



### Example Script

```python
# Go through the global feed, comment and follow the author if they have < 10 followers

global_feed = byte.me().global_feed()

for post in global_feed.feed:
    if post.author.followers['followerCount'] > 10:
      	post.comment("Hey man, thanks for making me laugh!")
        post.like()
    else:
      	continue


```

### Example Scripts

```python
# Go through your posts and comment any post older than 3 days and has less than 200 likes

my_posts = byte.me().posts()
time_now = datetime.datetime.now()

for post in my_posts.feed:
    if (time_now - post.date).days > 3:
        if post.like_count < 200:
            # i am not popular :(
            post.comment("this post isn't making me popular")
         else:
            post.comment("Woohoo! I'm very popular!")
    else:
        # not old enough
        continue
```

# Tests
Coming soon
cateye 0.4.4
A hint-enabled search engine framework for biomedical classification systems
License: MIT
Keywords: cateye

# Cateye

A hint-enabled search engine framework for biomedical classification systems

[![Build Status](https://travis-ci.org/jeroyang/cateye.svg?branch=master)](https://travis-ci.org/jeroyang/cateye)
[![](https://img.shields.io/pypi/v/cateye.svg)](https://pypi.python.org/pypi/cateye)

## Features
- Hint: Show hints for search terms which can narrow down the results fast.
- Fallback: If no result satisfying the query, the system automatically eliminates less important search terms.
- Spelling correction: Build-in spelling correction for query terms.
- Abbreviation expansion: Pre-defined abbreviation list will be automatically applied during the search
- Sorted results: Sort the results according to the search history.

## Installation

```bash
$ git clone https://github.com/jeroyang/cateye.git
$ cd cateye
$ pip install -e .
```

## Usage

### 1. Run the Demo Site:
```bash
$ FLASK_APP=application.py FLASK_ENV=development flask run
```
Then browse the local site http://127.0.0.1:5000/
Try to search "rhinitis"

### 2. Make your own site:

#### 2-1. Check the constants.py:
Setup the essential variables in the constants.py:
*SITE_TITLE, SITE_SUBTITLE, TOKEN_FOLDER, SNIPPET_FOLDER, HINT_FOLDER, SPELLING_FILE, ABBREVIATION_FILE, INDEX_URL*

The *INDEX_URL* will be used in the Shove object, which can be a local URL starts with file:// please check the document of [Shove](https://pypi.org/project/shove/).

#### 2-2. Data preparing
Folders overview:
  - *data:* The data source for the search engine, all information in this subfolders using the term id as their filenames
  - *data/token:* The tokens of the documents, after lemmatization
  - *data/snippet:* The HTML snippets of the documents, which will be shown on the search results
  - *data/hint:* The hints for each entity
  - *data/spelling.txt:* The formal spelling of your tokens (before normalization). If possible, sort the tokens with the frequency of usage, the most common word the first.
  - *data/abbreviation.txt:* The abbreviations, one line for one abbreviation pair, using tab to separate the short form and long form

Cateye include some very basic text processing tools:
tokenizer (cateye.tokenize) and lemmatizer (cateye.lemmatize)

The tokenize function will be used in two places: the first place is to cut your documents into tokens, and the second place is to cut your query into tokens.

The lemmatizing function will normalize your tokens. If you wish to build a case-insensitive search engine, you may use lowercase lemmatizer on the tokens.

#### 2-3. Build the index:
Run the command in the command line
```bash
$ cateye newindex
```
This command read the files in the *token_folder* and build an on-disk index in the *index_url*. It takes time depending on the size of your data.

#### 2-4. Run your application:
```bash
$ FLASK_APP=application.py FLASK_ENV=development flask run
```

## License
* Free software: MIT license
qr3 1.0.1
Redis-powered queues, capped collections, deques, and stacks
License: MIT
Keywords: Redis,queue,data structures

Full documentation (with example code) is at http://github.com/doctorondemand/qr3

QR3
=====

**QR3** helps you create and work with **queue, capped collection (bounded queue),
deque, and stack** data structures for **Redis**. Redis is well-suited for
implementations of these abstract data structures, and QR3 makes it even easier to
work with the structures in Python.

Quick Setup
------------
You'll need [Redis](http://github.com/antirez/redis/ "Redis") itself (QR makes use 
of MULTI/EXEC, so you'll need the Git edge version), and the current Python interface
for Redis, [redis-py](http://github.com/andymccurdy/redis-py "redis-py"). 

Run setup.py to install qr3 or 'pip install qr3'.

Responding to PR's
------------------
Given that this package primarily supports internal use cases, we cannot guarantee a 
specific response time on PRs for new features. However, we will do our best to 
consider them in a timely fashion.

We do commit to reviewing anything related to a security issue in a timely manner. 
We ask that you first submit anything of that nature to security@doctorondemand.com 
prior to creating a PR and follow responsible disclosure rules.

Thanks for your interest in helping with this package!
pheed 0.0.1
Python tools for aggregating physics literature
License: MIT

# Python tools for aggregating physics literature

The `pheed` (PHysics fEED) package collects physics literature meta data from various online sources and normalizes
the resulting data into a standard format. The package provides three principal data structures. A simplified summary, 
a `Source` produces and `Article` which has an `Author`. It is possible to search for new articles from a source given
some temporal and categorial information, such as "new this week" or "quantum gravity", as well as search for new 
articles by particular authors. Where official APIs exist, we use them, else we resort to web-scraping. As a 
consequence, the pdf form of the articles may not always be available. We aim to add these features where possible
while respecting the Terms and Conditions of the sources involved. The package hasn't added explicit support for 
non-peer-reviewed sources, such as Blogs, though we realize that these can be quite popular in the community and 
may add support in the future.


## Principal Structure

The below outlines the key components of the `pheed` package, and defines some of the relevant attributes or purposes
of each. Examples below will explain usage of each of these components.

- `Source`: An online origin for physics articles
- `Article`: A peer-reviewed publication, typically consisting of a pdf and some meta-data
- `Author`: Contributor to an `Article`, with the expected attributes (name, etc.)


## Wrapped Sources

Though the `pheed` package contains all the tools necessary to wrap additonal sources,
it comes with several sources already wrapped out of the box:

- APS Journals
- IOP Journals
- Arxiv