semvec/pypi-packages huggingface dataset:
any-document-extractor 0.1.3
A Python library for extracting text content from any document format.
Requires Python: >=3.9

# Any document Extractor

A Python library for extracting text content from any document format.

## Features

- Supports multiple document formats (PPTX, DOCX, PDF, XLSX.)
- Returns clean extracted text

## Installation

```bash
pip install any-document-extractor
````



## Usage
Basic usage example:

```python

from anydocumentextractor import DocumentExtractor


def main(fp: str):
    extra = DocumentExtractor(fp)
    return extra.extract()


if __name__ == '__main__':
    fp = 'text.docx'  # Can be any supported document
    content = main(fp)
    print(content)

```

## Supported Formats
- Microsoft Office: PPTX, DOCX, XLSX
- OpenDocument: ODT, ODP
- PDF documents
- Plain text files
- And more...

## build to PYPI

```shell
rm -rf dist/ build/ *.egg-info/
python setup.py sdist bdist_wheel
twine upload dist/*
```

## License
MIT License - Free for commercial and personal use.

You can customize this further by adding:
- More detailed installation instructions
- Specific version requirements
- Advanced usage examples
- Error handling documentation
- Contribution guidelines
- Project status badges
django-tracker-unergy 1.2.5
A Django app for advanced logging capabilities
Requires Python: >=3.10.13
Keywords: django, logging, audit, tracking

# Django Tracker

Django Tracker is a middleware for Django that automatically audits and logs all model changes made through user requests. It records the user responsible, the fields changed, and other useful information for tracking data changes.

## Installation

```bash
pip install django-tracker-unergy
```

## Setup

1. Add `'django_tracker'` to `INSTALLED_APPS` in your `settings.py`:

```python
INSTALLED_APPS = [
    # ...
    'django_tracker',
]
```
and add the middleware
```python
MIDDLEWARE = [
    # ...
    'django_tracker.middleware.CurrentUserMiddleware'
]
```

2. Run migrations:

```bash
python manage.py makemigrations
python manage.py migrate django_tracker
```

## Usage

### Auditable Decorator

```python
from django_tracker.decorators import auditable

@auditable(
    tracked_fields=['field1', 'field2'],
    exclude_fiels=["created_at", "updated_at"]
    audit_creates=True,
    audit_updates=True,
    audit_deletes=True,
    level=AuditLevel.MEDIUM
)
class MyModel(models.Model):
    field1 = models.CharField(max_length=100)
    field2 = models.IntegerField()
    # And the control attrb
```

### Querying Audit Logs

You can view audit logs in the Django admin or directly from the model:

```python
from django_tracker.models import AuditLog

# Get changes for a specific object
logs = AuditLog.objects.filter(
    content_type__model='mymodel',
    object_id=obj_id
)

# Get changes by user
logs = AuditLog.objects.filter(username='username')
```

## License

MIT License. See LICENSE file for details.
quasar-client 0.1.26
Legion Intelligence Python ML Inference Client
Requires Python: >=3.8

# Quasar Python Client

[![PyPI version](https://img.shields.io/pypi/v/quasar-client.svg)](https://pypi.org/project/quasar-client/)

## Installation

```sh
pip install quasar-client
```

## Usage

```python
from quasar_client import Quasar

quasar_base = "URL for Quasar-compatible server"
quasar = Quasar(quasar_base=quasar_base)

# Use OpenAI-compatible interfaces...
chat_completion = quasar.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Hello quasar",
        }
    ],
    model="gpt-3.5-turbo",
)

# Use Quasar-specific interfaces like NER...
entities = quasar.tagger.tag(
    task="ner", 
    text="Yurts Technologies is based in SF."
)
```

Quasar provides a convenient interface for common RAG APIs. In addition to the OpenAI APIs, the client supports:

- Coreference Resolution
- Entities
- Embedding
- Ranking
- Topics/Keywords

## Asynchronous Support

For developers looking to leverage asynchronous programming for improved performance and non-blocking IO operations, Quasar introduces async support for its APIs. This allows you to efficiently handle large volumes of requests and data processing in a non-blocking manner.

### Async Usage Example

Below is an example of how to use the asynchronous interface for embedding texts:

```python
from quasar_client import AsyncQuasar

quasar_base = "URL for Quasar-compatible server"
quasar = AsyncQuasar(quasar_base=quasar_base)

# Asynchronously embed texts
async def embed_texts(texts):
    embeddings = await quasar.embedding.embed(texts=texts)
    return embeddings

# Example texts
texts = ["Hello, world!", "How are you?"]

# Remember to run this in an async context
```

This async support ensures that your application can scale more efficiently, handling concurrent operations without the need for complex threading or multiprocessing setups.

### Sync and Async Resource Modules

Quasar provides both synchronous and asynchronous resource classes to cater to different use cases and preferences. Whether you prefer the simplicity of synchronous code or the efficiency of asynchronous operations, Quasar has you covered.

```python
# Synchronous Embedding Resource Class
class SyncEmbeddingResource(SyncResource):
    ...

# Asynchronous Embedding Resource Class
class AsyncEmbeddingResource(AsyncResource):
    ...
```
hack4u-001 0.5.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`:

```python3
pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Obtener un curso por nombre

```python
from hack4u import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

### Calcular duración total de los cursos

```python3
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```