semvec/pypi-packages huggingface dataset:
dita-parser 1.0.6
DITA File Merger and Splitter Utility

# DITA File Merger and Splitter Utility

This utility is designed to merge multiple DITA files into single XML files and split merged XML files back into
individual DITA files. This facilitates easier handling and translation of large sets of DITA documents.

## Table of Contents

- [Getting Started](#getting-started)
    - [Prerequisites](#prerequisites)
    - [Installation](#installation)
- [Usage](#usage)
- [Running the Tests](#running-the-tests)

## Getting Started

These instructions will help you get a copy of the project up and running on your local machine for development and
testing purposes.

### Prerequisites

- Python 3.12 or newer

### Installation

**For Regular Use:**

You can install the `dita-parser` package directly from PyPI using pip:

```bash
pip install dita-parser
```

**For Development:**

If you want to contribute to the project or modify it, you can clone the repository to your local machine:

1. Clone the repository to your local machine:

```bash
git clone git@git.crosslang.dev:crosslang/dita_parser.git
```

2. Navigate to the project directory:

```bash
cd dita_parser
```

3. Install the required dependencies:

```bash
pip install -r requirements.txt
```

### Running the Tests

To run the tests, navigate to the tests directory and run the unittest module:

```bash
cd tests
python -m unittest
```

### Usage

After installing dita-parser, you can use it directly from the command line without invoking Python directly.

Print Help:

```bash
dita-parser -h
```

To Merge DITA Files:

```bash
dita-parser merge <path/to/input> <path/to/output>
```

To Split XML Files:

```bash
dita-parser split <path/to/input> <path/to/output>
```

Replace <path/to/input> with the path to your input directory containing .dita or .xml files, and <path/to/output> with
the path to the directory where you want the output files to be saved.
Flask-Hashids 1.0.3
Hashids integration for Flask applications.
Requires Python: >=3.5

# Flask-Hashids

Hashids integration for Flask applications, it is based on the [Hashid](https://github.com/davidaurelio/hashids-python) package available on [PyPi](https://pypi.org/project/hashids/). With this extension you can conveniently use integer ids for your application logic or database tables and hash them before exposing it in URLs or JSON data.

## Installation

The latest stable version [is available on PyPI](https://pypi.org/project/Flask-Hashids/). Either add `Flask-Hashids` to your `requirements.txt` file or install with pip:

```
pip install Flask-Hashids
```

## Configuration

Flask-Hashids is configured through the standard Flask config API. These are the available options:

- **HASHIDS_ALPHABET**: Read more about that in [Hashids documentation](https://github.com/davidaurelio/hashids-python#using-a-custom-alphabet)
- **HASHIDS_MIN_LENGTH**: Read more about that in [Hashids documentation](https://github.com/davidaurelio/hashids-python#controlling-hash-length)
- **HASHIDS_SALT**: It is strongly recommended that this is NEVER the same as the `SECRET_KEY`. Read more about this option in [Hashids documentation](https://github.com/davidaurelio/hashids-python#using-a-custom-salt)

## Examples

You can find more detailed examples on how to use Flask-Hashids in the examples directory.

```python
from flask import Flask, jsonify, url_for
from flask_hashids import HashidMixin, Hashids
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
app.config['SECRET_KEY'] = 'top_secret_key'
app.config['HASHIDS_SALT'] = 'secret!'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = SQLAlchemy(app)
hashids = Hashids(app)


# The HashidMixin class adds the hashid property which will compute a hashid
# based on the existing id attribute of the instance.
# NOTE: The id attribute must be an int
class User(HashidMixin, db.Model):
    __tablename__ = 'users'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), nullable=False)

    @property
    def url(self):
        # The HashidConverter encodes the given id to a hashid in the URL
        return url_for('user', user_id=self.id)

    def to_json_serializeable(self):
        return {'id': self.hashid, 'name': self.name, 'url': self.url}


@app.before_first_request
def database_setup():
    db.create_all()
    john = User(name='John')
    db.session.add(john)
    jane = User(name='Jane')
    db.session.add(jane)
    db.session.commit()


@app.route('/users')
def users():
    return [user.to_json_serializeable() for user in User.query.all()], 200


@app.route('/users/<hashid:user_id>')
def user(user_id: int):
    # The HashidConverter decodes the given hashid to an int
    user = User.query.get(user_id)
    if user is None:
        return jsonify('User not found'), 404
    return user.to_json_serializeable(), 200


def main():
    # You can encode and decode hashids manually
    id = 123
    encoded_id = hashids.encode(id)
    decoded_id = hashids.decode(encoded_id)
    app.run()


if __name__ == '__main__':
    main()
```


## Resources

- https://hashids.org/python/
PyPublicaties 0.2.3
A Python library which can be used to interact with the Dutch government's publication repository.

# PyPublicaties

`PyPublicaties` is a Python library that facilitates easy access to the 'officielepublicaties' collection through the [SRU 2.0 interface provided by the Dutch government](https://data.overheid.nl/sites/default/files/dataset/d0cca537-44ea-48cf-9880-fa21e1a7058f/resources/Handleiding%2BSRU%2B2.0.pdf). This library simplifies the process of querying, retrieving, and managing 'officiële publicaties' with just a few lines of code.

## Features

- Easy construction of queries for searching within the 'officielepublicaties' collection.
- Retrieval of publications with options to limit the number of records.
- Direct access to publication details such as identifiers and titles in a Python-friendly way.

## Installation

Install `PyPublicaties` using pip:

```bash
pip install PyPublicaties
````

## Quick Start


Here's a simple example to get you started with PyPublicaties:
```python
from PyPublicaties import retrieve_publications

query_list = [
    'w.subrubriek=Stemmingen',
    'dt.identifier=h-tk-20192020-46-12'
]

publications = retrieve_publications(query_list=query_list, max_records=100, start_record=1)

publication = publications[0]

```

This code will search for publications under the 'Stemmingen' subcategory and print details for up to 100 of them. The function always returns a list of objects

This allows for easy interaction in an object oriented way. For example, this code will access the title of the first retrieved result:

````python
print(publication.title[0])
````
````bash
Stemming Wet wijziging woonplaatsbeginsel
````

For consistency, every variable of the object is returned as a list since some variables hold multiple values. 


## Documentation

For more detailed information on all the capabilities, documentation will be made available in a later stadium.

## Contributing

Contributions are welcome! If you'd like to contribute, please fork the repository and submit a pull request with your changes.

## Support

If you encounter any issues or have questions, please submit an issue on the GitHub issues page.

## License

PyPublicaties is released under the MIT License. See the LICENSE file for more details.
python-pilot 0.0.11
A python terminal with coding copilot inside
Requires Python: >=3.9,<4.0

# PyPilot
A python terminal with a coding copilot inside.</br>
This is a regular python terminal, only that your comments are used as requests from the copilot.</br>
Don't forget to set the API KEY (supports only OPENAI for now).

## Demo
<img src="./assets/demo.gif" />

## Features
- Code generation inside the python terminal.
- Your comments are used to communicate with the copilot.
- The copilot is aware of the terminal history and locals.
- Both code and chat responses are supported.
- Supports system commands from within the terminal (e.g. !pip install <package_name>).
- Supports all OpenAI models.

## Installation
```bash
$ pip install python-pilot
```

## Usage
```bash
$ pypilot --api-key sk-....
```
or
```bash
$ export OPENAI_API_KEY=sk-... 
$ pypilot
```

# TODO
- add a way to use history only with headers of functions...
- docker containers
- add a selector step that decide what context the next llm prompt should have:
    - history: code executed (w/wo expressions), errors, llm requests
    - locals: vars, functions, modules
 (full terminal history, locals only) and if the output should be code or chat
- add support in llm config file
work-monitor 0.1.4
monitor work environment by camera
Requires Python: >=3.7

### Work-Monitor

I create this project to monitor my work environment by laptop camera.

This project will capture photo intervally and combined them into a video.

### Usage

Get help.

```bash
python3 -m monitor help
```

Start the monitor server.

```bash
python3 -m monitor server
```

As a client, you can control the monitor server by sending commands to the server.

```bash
# Stop the monitor server.
python3 -m monitor stop
# Get the monitor server config
python3 -m monitor get_config
```

### Requirements

- Python 3.6+
- OpenCV 3.4+
- Numpy 1.16+

### Installation

```bash
pip3 install work-monitor
```