semvec/pypi-packages huggingface dataset:
odoo-domain-converter 0.1.0
Convert human-readable expressions to Odoo domain format
Requires Python: >=3.6

# odoo-domain-converter
This tool converts human-readable logical expressions into Odoo domain format and validates them against an Odoo server using OdooRPC.

## Installation

You can install the package directly from PyPI:

```bash
pip install odoo-domain-converter
```

Or install from source:

```bash
git clone https://github.com/0yik/odoo-domain-converter.git
cd odoo-domain-converter
pip install -e .
```

## Usage

### As a Command Line Tool

```bash
odoo-domain-converter --host localhost --port 8069 --database mydb \
                     --username admin --password admin \
                     --model res.partner \
                     --expression "name = 'John' & is_company = True"
```

### As a Python Package

```python
from odoo_domain_converter import ComplexDomainConverter

# Initialize the converter
converter = ComplexDomainConverter()

# Convert an expression to Odoo domain
expression = "name = 'John' & is_company = True"
domain = converter.to_domain(expression)
print(domain)  # ['&', ('name', '=', 'John'), ('is_company', '=', True)]

# Test the domain against an Odoo server
from odoo_domain_converter import test_in_odoo

success, message = test_in_odoo(
    domain=domain,
    model='res.partner',
    host='localhost',
    db='mydb',
    username='admin',
    password='admin'
)
print(message)  # "Valid (found X records)"
```

## Example Expressions

All examples below use real fields from `res.partner` model:

```
# Basic conditions
name = 'John'                           -> [('name', '=', 'John')]
email = 'john@example.com'              -> [('email', '=', 'john@example.com')]
is_company = True                       -> [('is_company', '=', True)]
active = True                           -> [('active', '=', True)]

# Logical combinations
name = 'John' & is_company = False      -> ['&', ('name', '=', 'John'), ('is_company', '=', False)]
email ilike '%@example.com' | email ilike '%@test.com'  
-> ['|', ('email', 'ilike', '%@example.com'), ('email', 'ilike', '%@test.com')]

# Nested conditions
(name = 'John' & is_company = True) | active = True
-> ['|', '&', ('name', '=', 'John'), ('is_company', '=', True), ('active', '=', True)]

# Special operators
parent_id child_of 1                    -> [('parent_id', 'child_of', 1)]
name not_like 'Test%'                   -> [('name', 'not like', 'Test%')]
name not_ilike 'test%'                  -> [('name', 'not ilike', 'test%')]
category_id in [1, 2]                   -> [('category_id', 'in', [1, 2])]
user_ids not_in [1, 2, 3]              -> [('user_ids', 'not in', [1, 2, 3])]

# Odoo expressions
user_id = self.env.user.id             -> [('user_id', '=', self.env.user.id)]
company_id = self.env.company.id       -> [('company_id', '=', self.env.company.id)]
```

## Note on Operators

For operators with spaces, use underscore:
- Use `not_like` instead of `not like`
- Use `not_ilike` instead of `not ilike`
- Use `not_in` instead of `not in`

## License

This project is licensed under the MIT License - see the LICENSE file for details.
hack4u-MDFK-Kilombos 0.1.0
Una biblioteca para consultar cursos de hack4u.

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursos de la academia Hack4U.

## Cursos disponibles:
- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación

Instala el paquete usando `pip3`:

```bash
pip3 install hack4u
balekit 0.0.3
A tool for developing bots in Bale messenger!
Requires Python: >=3.8

## BaleKit
A tool for developing bots in Bale messenger!
## Quick Example
```python
from balekit import Bot
app = Bot("TOKEN")
async def main():
    await app.send_message(1234567890,"Hello World!")
app.run(main)
```
## Contact Us
- [Bale](https://ble.ir/mpmms)
- [Telegram](https://t.me/mpm_ms)
- [GitHub Issues](https://github.com/mpmms/balekit/issues)

## Installing

```bash
pip install balekit==0.0.3
```
vonage-http-client 1.5.1
An HTTP client for making requests to Vonage APIs.
Requires Python: >=3.9

# Vonage HTTP Client Package

This Python package provides a synchronous HTTP client for sending authenticated requests to Vonage APIs.

This package (`vonage-http-client`) is used by the `vonage` Python package and SDK so doesn't require manual installation or config unless you're using this package independently of a SDK.

The `HttpClient` class is initialized with an instance of the `Auth` class for credentials, an optional class of HTTP client options, and an optional SDK version (this is provided automatically when using this module via an SDK).

The `HttpClientOptions` class defines the options for the HTTP client, including the API and REST hosts, timeout, pool connections, pool max size, and max retries.

This package also includes an `Auth` class that allows you to manage API key- and secret-based authentication as well as JSON Web Token (JWT) authentication.

For full API documentation refer to the [Vonage Developer documentation](https://developer.vonage.com).

## Installation (if not using via an SDK)

You can install the package using pip:

```bash
pip install vonage-http-client
```

## Usage

```python
from vonage_http_client import HttpClient, HttpClientOptions
from vonage_http_client.auth import Auth

# Create an Auth instance
auth = Auth(api_key='your_api_key', api_secret='your_api_secret')

# Create HttpClientOptions instance
options = HttpClientOptions(api_host='api.nexmo.com', timeout=30)

# Create a HttpClient instance
client = HttpClient(auth=auth, http_client_options=options)

# Make a GET request
response = client.get(host='api.nexmo.com', request_path='/v1/messages')

# Make a POST request
response = client.post(host='api.nexmo.com', request_path='/v1/messages', params={'key': 'value'})
```

### Get the Last Request and Last Response from the HTTP Client

The `HttpClient` class exposes two properties, `last_request` and `last_response` that cache the last sent request and response.

```python
# Get last request, has type requests.PreparedRequest
request = client.last_request

# Get last response, has type requests.Response
response = client.last_response
```

### Appending to the User-Agent Header

The `HttpClient` class also supports appending additional information to the User-Agent header via the append_to_user_agent method:

```python
client.append_to_user_agent('additional_info')
```

### Changing the Authentication Method Used

The `HttpClient` class automatically handles JWT and basic authentication based on the Auth instance provided. It uses JWT authentication by default, but you can specify the authentication type when making a request:

```python
# Use basic authentication for this request
response = client.get(host='api.nexmo.com', request_path='/v1/messages', auth_type='basic')
```

### Catching errors

Error objects are exposed in the package scope, so you can catch errors like this:

```python
from vonage_http_client import HttpRequestError

try:
    client.post(...)
except HttpRequestError:
    ...
```