semvec/pypi-packages huggingface dataset:
query-everywhere 0.1.10
Query every resource in RDBMS for REST
Requires Python: >=3.11,<4.0

# Query Everywhere

query your data in every RDBMS.

## Install

```bash
pip install query-everywhere
```

## Notices

* You should install your db driver(like `psycopg2-binary`) before use.

## Example

```python
from query_everywhere import Queryer

# Create a Queryer with DSN
dsn = "sqlite:///db.sqlite3"
queryer = Queryer(dsn)


# Query
filters = [
    ("name__contains", "part of name"),
    ("age__gte", 20),
    ("age__lt", 30),
    ("address__neq", "beijing"),
    ("address__eq", "shanghai"),
    ("address__icontains", "beijing"),
]
order = "create_time desc"
limit = 10
offset = 0
data = queryer.query("people", filters, order, limit, offset)
print(data)

# It where do 
# SELECT * FROM "people" WHERE name LIKE ? AND age >= ? AND age < ?
# AND address != ? AND address = ? AND LOWER(address) LIKE ? ORDER BY ? LIMIT ? OFFSET ?
```

## Supported operators

| Operator | Comment |
| --- | --- |
| eq | equal to |
| neq | not equal to |
| ne | not equal to |
| lt | less than |
| gt | greater than |
| lte | less than or equal to |
| gte | greater than or equal to |
| startswith | starts with the given value |
| endswith | ends with the given value |
| contains | contains the given value |
| icontains | contains the given value in the case-insensitive way |
| isnull | is null |
pycompall 0.2.0
Pycompall is a wrapper around the default `compileall` Python utility to compile `.py` to `.pyc` files to provide a more configurable interface and as a build tool when configuring python files.
Requires Python: >=3.7
Keywords: obfuscation,python-obfuscation,python-compiler

# Pycompall Package
Pycompall is a wrapper around the default `compileall` Python utility to compile `.py` to `.pyc` files to provide a more configurable interface and as a build tool when configuring python files.

This package is also useful for code obfuscation, especially since most `.py` files can be substituted for their compiled bytecode equivalents most of the time.


## Installation
```sh
pip install pycompall
```

## Usage
`pycompall compile [OPTIONS] [PATH]`. 

Without any options, this will compile all `.py` files in the current directory (or file) into the default `__pycache__` directory.

### Options
#### `-r`, `--recursive`

Recurse through subdirectories.

#### `--in-place`

Remove original `.py` files and replace them with compiled `.pyc` files.

#### `--create-empty-init`

Create an empty `__init__.py` file in the base directory path specified after compilation. Useful for interacting with other build tools such as colcon that require a package to have an `__init__.py` file.

- Note: this only adds the file in the **base directory** specified, regardless of whether the `--recursive` flag is specified.

#### `--exclude-files TEXT`  

Exclude pattern(s) for files to be excluded during                    compilation and replacement.

- Note: this option supports globbing patterns with python's `Path.match` method, but this requires globs to be passed as strings to the tool, so you must wrap the glob in quotes (e.g. `pycompall compile --exclude-files '*.py'`).
- To specify multiple files to exclude, write the flag again (e.g. `pycompall compile --exclude-files '*test.py' --exclude-files 'test/*.py'`)

#### `--exclude-dirs TEXT` 

Exclude pattern(s) for directories to be excluded during compilation and replacement. Note that if the directory is skipped and --create-empty-init is True, the `__init__.py` file will not be created.

- Note: this option supports globbing patterns with python's `Path.match` method, but this requires globs to be passed as strings to the tool, so you must wrap the glob in quotes (e.g. `pycompall compile --exclude-dirs 'test*'`).
- To specify multiple directories to exclude, write the flag again (e.g. `pycompall compile --exclude-dirs 'test' --exclude-dirs 'utils'`)

#### `--ignore-symlinks`

Sometimes symlinks causes problems. Enable this flag to ignore symlinks.
pwvalid 0.4
Validate Emails with ease



# PWValid Email Validation 

PWValid is a powerful and very simple Python package to validate and check emails. It helps developers tackle spam and disposable emails.

[![Downloads](https://static.pepy.tech/badge/pwvalid)](https://pepy.tech/project/pwvalid)



### Features:
+ Fast Response
+ Very Accurate
+ Easy to Implement
+ No Need to use External APIs
+ No Need for Any API Key

### Installation
**Pip Command**

```
pip install pwvalid
```

### How to use?

**Import pwvalid Package**

```
import pwvalid
```

### InBuilt Functions:
#### EmailValidate Fuction:
It checks and validates the emails and returns a complete response with all available metrics.

```
pwvalid.EmailValidate('youremail@gmail.com')
```


#### Avaliable Metrics
```
result = pwvalid.EmailValidate('youremail@gmail.com')
```
+ _email_address_ : `result['email_address']` | Response Type: String
+ _domain_ : `result['domain']` | Response Type: String
+ _disposables_ : `result['disposable']` | Response Type: Bool
+ _webmails_ : `result['webmail']` | Response Type: Bool
+ _deliverable_ : `result['deliverable']` | Response Type: Bool
+ _valid_syntax_ : `result['valid_syntax']` | Response Type: Bool
+ _catch_all_ : `result['catch_all']` | Response Type: Bool
+ _gibberish_ : `result['gibberish']` | Response Type: Bool
+ _spam_ : `result['spam']` | Response Type: Bool

Example Response:

```
{
  'email_address': 'kush@gmail.com',
  'domain': 'gmail.com',
  'valid_syntax': True,
  'disposable': False,
  'webmail': True,
  'deliverable': False,
  'catch_all': False,
  'gibberish': False,
  'spam': False
}
```


---
#### isDisposable Fuction:
It checks if an email is disposable or not. It returns a boolean response (True/False).

```
pwvalid.isDisposable('youremail@gmail.com')
```

---
#### isDeliverable Fuction:
It Checks if an email is Deliverable or not. it returns a Bool response. (True/False)

```
pwvalid.isDeliverable('youremail@gmail.com')
```

---
#### isSpam Fuction:
It Checks if an email is Spam or not. it returns a Bool response. (True/False)

```
pwvalid.isSpam('youremail@gmail.com')
```

---

### Code Examples
```
import pwvalid 
email = input('Enter Email:')
result = pwvalid.isSpam(email)
print(result)
```

### Support This Project
[![paypal](https://img.shields.io/badge/PayPal-00457C?style=for-the-badge&logo=paypal&logoColor=white)](https://www.paypal.com/paypalme/itsvinaychaudhary) 

[![coffee](https://img.shields.io/badge/Buy_Me_A_Coffee-FFDD00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/vinay_dev)

### Author
The PWValid Package is created by [Vinay Chaudhary](https://buymeacoffee.com/vinay_dev). This Project is Powered by [Regem Enterprises](https://regem.in)
hstreamdb 0.5.0
Python client for HStreamDB
Requires Python: >=3.7

# hstreamdb-py

Python client for [HStreamDB](https://github.com/hstreamdb/hstream)

## Installation

Create a new virtual environment if you prefer to use isolated environments:

```sh
virtualenv -p python3 ./venv
source ./venv/bin/activate
```

Install hstreamdb:

```sh
pip install hstreamdb
```

## Examples

Here's a basic example (For more examples and api documentation, see:
<https://hstreamdb.github.io/hstreamdb-py/>) :

```python
$ python

>>> from hstreamdb import insecure_client
>>> async def main():
...     async with await insecure_client(host="127.0.0.1", port=6570) as client:
...         streams = await client.list_streams()
...         print(list(streams))
...
>>> import asyncio
>>> asyncio.run(main())
```