semvec/pypi-packages huggingface dataset:
keyword-extract-links 0.0.4
This is a package that extracts keyword links based on web keywords
Requires Python: >=3.6
Keywords: extracts keyword links based on web keywords

> pip install keyword_extract_links

> httpx,fake_useragent must be installed to test before use,but the keyword_extract_Links library is not dependent

```
from keyword_extract_links import extract_links
import httpx
from fake_useragent import UserAgent
ua = UserAgent()


def get_html(url_address):
    headers = {'user-agent': ua.random}
    r = httpx.get(url_address, headers=headers)
    return r.text


url_list = [
              "https://tieba.baidu.com/f/search/res?ie=utf-8&qw=%E6%98%93%E6%AC%A1%E5%85%83",
              "https://s.weibo.com/weibo?q=%E6%98%93%E6%AC%A1%E5%85%83&Refer=STopic_history"
           ]
for url in url_list:
    html = get_html(url)
    extract = extract_links.Extract(url, html, "易次元")
    url_list = extract.get_url_list()
    print(url_list)

# ['https://tieba.baidu.com/home/main?un=%E6%98%93%E6%AC%A1%E5%85%83&from=tieba']
# ['https://weibo.com/6509857538?refer_flag=1001030103_', 'https://app.weibo.com/t/feed/2nxWC7', 'https://k.sina.cn/article_5790946818_1592ad6020010112vs.html?from=animation&wm=3049_0032', 'https://c.m.163.com/news/a/EQ35KNJQ00318PFH.html?spss=newsapp']
```
flagsup 0.0.2
A Feature Flags management SDK

### Installation
```
pip install flagsup
```
### Integration
- Docs: [Integration doc](https://confluence.teko.vn/display/PS/User+guide+for+setting+up+feature+flags)
- Init client
  ```
  import flagsup
  flagsup_client = flagsup.CachedFlagsupClient("https://flagsup.dev.tekoapis.net")
  ```
- To get flag status (and experiment info if available) for a specific user using User IAM ID
  - `batchEvaluateFlags(<flagsup.EvaluateRequest>, [<default_status>, <default_treatment>, <default_exp_id>, <default_branch_id>])`
  - `evaluateFlag(<flag_key>, <iam_id>, [<default_status>, <default_treatment>, <default_exp_id>, <default_branch_id>])`
  
  It is recommended to call batchEvaluateFlags() for all your feature flags upon getting userId from IAM service
  Subsequently you can call evaluateFlag() to get flag value from in-memory cache
  
- To get flag status when user is not logged in (**note**: this will disable canary release, black/white list, experiment)
  - `batchGetFlags(<flag_key_list>, [<default_status>])`
  - `getFlag(<flag_key>, [<default_status>])`
  
  Similar to `evaluateFlag` It is recommended to call `batchGetFlags()` for all your feature flags upon initial load
  Subsequently you can call `getFlag()` to get flag value from in-memory cache  
  
### Example
```
import flagsup

if __name__ == "__main__":
    # Initialisation, provide FlagSup SDK with target domain
    flagsup_client = flagsup.CachedFlagsupClient("https://flagsup.dev.tekoapis.net")

    # Option 1: Get flags with User ID

    # It is recommended to call batchEvaluateFlags() for all your feature flags upon getting userId from IAM service
    # Subsequently you can call evaluateFlag() to get flag value from in-memory cache

    # Fetch multiple flag values for the same or different users. Response is cached in memory for subsequent calls.
    # To reduce network overhead, call this to fetch all flags when your app initialise
    batch_response = flagsup_client.batch_evaluate_flag([
        flagsup.EvaluateRequest("flag01", "5f8e4768e00e4d12ba69ed3e7bf3e893"),  # pragma: whitelist secret
        flagsup.EvaluateRequest("flag02", "5f8e4768e00e4d12ba69ed3e7bf3e893"),  # pragma: whitelist secret
    ])

    # Fetch a flag value for the logged in user. Response is cached in memory for subsequent calls.
    flag_status = flagsup_client.evaluate_flag("flag01", "5f8e4768e00e4d12ba69ed3e7bf3e893")  # pragma: whitelist secret
    if flag_status:
        #  Flow when flag is enabled
        pass
    else:
        # // Flow when flag is disabled
        pass
    # Option 2: Get flags without User ID

    # Fetch multiple flag values. Response is cached in memory for subsequent calls.
    # To reduce network overhead, call this to fetch all flags when your app initialise
    batch_response = flagsup_client.batch_get_flag_status(["flag01", "flag02"])

    # Fetch a single flag value. Response is cached in memory for subsequent calls.
    flag_status = flagsup_client.get_flag_status("flag01")

```
multiline 1.0.2
A package to read multline json values

# multiline
Open source python module, which can parse multiline values in json files.
This module provides a wrapper on top of the four methods (load, loads, dump, dumps) present in the default json module. This is done to avoid the need of importing both modules `multiline` and `json`.

If multline parsing is required while loading the json, then an additional argument ```multiline=True``` needs to be provided to trigger the custom parser. More info on the package can be found at: https://sankettantia.medium.com/multiline-a-python-package-for-multi-line-json-values-c4f7a76f0305.
pyteleprint 1.0.4
A package for remote program alerts,prints and notification through Telegram
Requires Python: >=3.4

## Project Description

[![GPLv3 License](https://img.shields.io/badge/License-GPL%20v3-yellow.svg)](https://opensource.org/licenses/)


### pyteleprint

pyteleprint is a package for remote prints, notification and alerts for python programs. The notification mechanism is done via Telegram.

### Why should I use this?

This is meant for users who want print() to be a remote notification and alert mechanism if they are not present at their workstation when the program is being executed or for a persisting python application.

### Features

* Remote alerts
* Remote print
* Remote notification

### Requirements

* Requires Python -v >= 3.4.0 
* Telegram App

### Installation

```python
$ pip install pyteleprint
```

### Initial Preparations

The Telegram app must be installed into your mobile system.

First, create a personal bot using (@BotFather). Once the creation process is done, you will receive an API token. Note this API Token for further use.


### Using pyteleprint

Create a new script or use shell to execute the following code

```python
from pyteleprint.printer.chat_extract import ChatIDExtractor

API_TOKEN = "YOUR_NEW_BOT_API_TOKEN" # Obtained from creating a bot through BotFather
ChatIDExtractor(API_TOKEN).start()
```

Once the script is executed, the program would start polling for messages to get chat id. Send a message to your new bot. This will help the program extract the chat id. Use this chat id to send notifications and alerts.

If in future, you delete or lose the chat thread, you can redo the above process to get the new chat id.

This chat id can be used statically in any application at any point in time iff the chat thread with the bot exists. But, if the user deletes the chat with their bot then they have to re-extract the chat id since there would be a new chat thread to communicate with the bot.

Now, you have the API Token and the chat id with you, use them to create a Printer object in your scripts and use the print() method to send notifications,prints and alerts.

```python
from pyteleprint.printer.printer import Printer

API_TOKEN = "YOUR_BOT_API_TOKEN"
CHAT_ID = 12345 # Chat id obtained from ChatIDExtractor().start()
p = Printer(API_TOKEN,CHAT_ID)

p.print("Hello World")
```
django-redis-connector 1.0.4
Django Redis Connector
Keywords: Django Redis Connector

======================
django-redis-connector
======================

Django Redis Connector

Installation
============

::

    pip install django-redis-connector


Usage
=====

::

    from django_redis_connector import connector

    # Redis 设置
    REDIS = {
        'default': {
            'HOST': '127.0.0.1',
            'PORT': 6379,
            'USER': '',
            'PASSWORD': '',
            'db': 0,
        }
    }

    # Redis 连接
    REDIS_CACHE = connector(REDIS.get('default', {}))
Dangee 0.0.3
Dangee
Requires Python: >=3.8

# Dangee Framework

Dangee framework provides information of elements (function, variable etc.) in android binaries. Users can therefore, use these information to construct the analysis, find potential malicious activites or security vulnerabilities.

## Installation

```bash
pip install -U Dangee
```

## QuickStart

```python
from dangee.core import Dangee

d = Dangee("Roaming_Mantis.dex")
```

### Usage

1. Show all method

```python
d.value
```

2. Show Android native API

```python
d.isNative().value
```

3. Show self-defined method

```python
d.isSelfDefine().value
```
4. Matching method by case-insensitive words

```python
d.isNative().match("package").value
```

Multi-level match

```python
d.isNative().match("package").match("UsageStats").value
```

5. Crossreferences (XREFs)

```python

# XREFs FROM:
m1 = d.isNative().match("usage")
m1.get_xref_from().value

# XREFs TO:
m2 = d.isSelfDefine().match("getTopActivityName$loader_release")
m2.get_xref_to().value
```

6. Data flow check

```python
m1 = d.isNative().match("usage")
m2 = d.isNative().match("package")

m1.dataFlowto(m2)
```
> list[ {tuple(method1, method2) : result_of_data_flow_to_found } ]