semvec/pypi-packages huggingface dataset:
gt-examcard-parser 0.1.0
Parser for Philips ExamCards
Requires Python: >=3.6.0

# gt-examcard-parser 

Parser for Philips ExamCards. 

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install gtagora-connector.

```bash
pip install gt-examcard-parser 
```


## Basic usage

```python
import examcard as ec

filename = 'MyStudy.ExamCard'
examcard = ec.parse(filename)
```

## License
[MIT](https://choosealicense.com/licenses/mit/)
repo2text 0.1.1
A simple utility to convert repository files to text including specific file extensions
Requires Python: >=3.6

# repo2text

`repo2text` is a Python utility designed to convert entire code repositories into text format. This tool is particularly useful for those who want to feed repository contents into large language models like Gemini 1.5, GPT-4, Claude, and others that can process extensive context windows. By turning repositories into plain text, `repo2text` facilitates easy ingestion of codebases into models for tasks such as code analysis, summarization, or other AI-driven evaluations.

## Features

- Clone repositories and convert all files or specific types of files into a single text file.
- Ignore non-essential files like `.git` and `__pycache__`.
- Flexible command-line interface to specify file types.

## Installation

Install `repo2text` using pip:

```bash
pip install repo2text
```

## Usage

After installation, `repo2text` can be used directly from the command line:

To convert all files in a repository:
```bash
repo2text https://github.com/YashJain14/Mini-Twitter
```

To convert only specific file types (e.g., Python files):
```bash
repo2text .py https://github.com/YashJain14/Mini-Twitter
```

## Requirements

- Python 3.6 or higher
- GitPython

## Contributing

Contributions are welcome! If you have suggestions for improvements or bug fixes, please create an issue or pull request.

## License

`repo2text` is released under the MIT License. See the `LICENSE` file for more details.
dotlink 2.1
Automate deployment of dotfiles to local paths or remote hosts
Requires Python: >=3.8

dotlink
=======

Automate deployment of dotfiles to local paths or remote hosts

[![version](https://img.shields.io/pypi/v/dotlink.svg)](https://pypi.org/project/dotlink)
[![changelog](https://img.shields.io/badge/change-log-blue)](https://github.com/amyreese/dotlink/blob/main/CHANGELOG.md)
[![license](https://img.shields.io/pypi/l/dotlink.svg)](https://github.com/amyreese/dotlink/blob/main/LICENSE)


install
-------

    $ pipx install dotlink


usage
-----

List your dotfiles in a simple text format named either `.dotlink` or `dotlink`:

    # comments are lines starting with hash

    # simple file listing
    .vimrc
    .zshrc

    # map files to different names/paths (destination = source)
    .config/htop/htoprc = htoprc

    # include configs from submodules or other directories
    @submodule/

See example repo/config at https://github.com/amyreese/dotfiles

Tell dotlink where your dotfile repo is, and where it should put things.
Defaults to the current directory and your home directory, respectively:

    $ dotlink [<source>] [<destination>]

Use `--plan` to see what dotlink will do before doing it:

    $ dotlink --plan [...]

The source can be a cloneable git repo:

    $ dotlink https://github.com/amyreese/dotfiles.git

The destination can be a remote, ssh-able location:

    $ dotlink <source> [<user>@]host:/path/to/destination


legal
-----

dotlink is copyright [Amethyst Reese](https://noswap.com).

dotlink is licensed under the MIT license.
See the `LICENSE` file for more details.
miner-viz 0.0.1.dev0
Minecraft Bedrock Edition World Visualization Tool
Requires Python: >=3.7

# Miner Viz

## Test call

```python
import miner_viz

miner_viz.add(1, 2)
```

## Files

This example has several files that are a good idea, but aren't strictly
necessary. The necessary files are:

* `pyproject.toml`: The Python project file
* `CMakeLists.txt`: The CMake configuration file
* `src/main.cpp`: The source file for the C++ build
* `src/miner_viz/__init__.py`: The Python portion of the module. The root of the module needs to be `<package_name>`, `src/<package_name>`, or `python/<package_name>` to be auto-discovered.

These files are also expected and highly recommended:

* `.gitignore`: Git's ignore list, also used by `scikit-build-core` to select files for the SDist
* `README.md`: The source for the PyPI description
* `LICENSE`: The license file

There are also several completely optional directories:

* `.github`: configuration for [Dependabot][] and [GitHub Actions][]
* `conda.recipe`: Example recipe. Normally you should submit projects to conda-forge instead of building them yourself, but this is useful for testing the example.
* `docs/`: Documentation
* `tests/`: Tests go here

And some optional files:

* `.pre-commit-config.yaml`: Configuration for the fantastic static-check runner [pre-commit][].
* `noxfile.py`: Configuration for the [nox][] task runner, which helps make setup easier for contributors.

This is a simplified version of the recommendations in the [Scientific-Python
Development Guide][], which is a _highly_ recommended read for anyone
interested in Python package development (Scientific or not). The guide also
has a cookiecutter that includes scikit-build-core and pybind11 as a backend
choice.

### CI Examples

There are examples for CI in `.github/workflows`. A simple way to produces
binary "wheels" for all platforms is illustrated in the "wheels.yml" file,
using [cibuildwheel][].

## License

pybind11 is provided under a BSD-style license that can be found in the LICENSE
file. By using, distributing, or contributing to this project, you agree to the
terms and conditions of this license.

[cibuildwheel]: https://cibuildwheel.readthedocs.io
[scientific-python development guide]: https://learn.scientific-python.org/development
[dependabot]: https://docs.github.com/en/code-security/dependabot
[github actions]: https://docs.github.com/en/actions
[pre-commit]: https://pre-commit.com
[nox]: https://nox.thea.codes
[pybind11]: https://pybind11.readthedocs.io
[scikit-build-core]: https://scikit-build-core.readthedocs.io
[scikit-build (classic)]: https://scikit-build.readthedocs.io
claroai 0.0b1
Claro AI Python client
Keywords: Claro AI, Claro API

# Claro AI python client
API for data ingestion

project:

- API version: 1.0.0
- Package version: 0.0.b0

## Requirements.

Python 3.7+

## Installation & Usage
### pip install

```sh
pip install claroai
```


Then import the package:
```python
import claroai
```

## Getting Started



```python
import claroai

from pprint import pprint

from claroai.rest import ApiException


configuration = claroai.Configuration(username="test", password="test")


with claroai.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    conversation_api_instance = claroai.ConversationApi(api_client)

    conversation_data_schema = claroai.ConversationData(
        [  # List[claroai.ConversationSchema] or claroai.ConversationSchema
            claroai.ConversationSchema(
                conversation_id="1",
                conversation_created_at="2021-01-01T00:00:00Z",
                user_id="1",
                messages=[
                    {
                        "id": "Thiyagu",
                        "role": "user",
                        "body": "What time does the team arrive?",
                        "created_at": "2020-02-20T20:19:34Z",
                    }
                ],
            ),
            claroai.ConversationSchema(
                conversation_id="2",
                conversation_created_at="2021-01-01T00:00:00Z",
                user_id="1",
                messages=[
                    {
                        "id": "Thiyagu 2",
                        "role": "user",
                        "body": "What time does the team arrive?",
                        "created_at": "2020-02-20T20:19:34Z",
                    }
                ],
            ),
        ]
    )

    interaction_api_instance = claroai.InteractionApi(api_client)

    interaction_data_schema = claroai.InteractionData(
        claroai.InteractionSchema(  # claroai.InteractionSchema or List[claroai.InteractionSchema]
            conversation_id="1",
            interaction_id="1",
            user_id="1",
            content="What time does the team arrive?",
            created_at="2020-02-20T20:19:34Z",
            interacted_at="2020-02-20T20:19:34Z",
        )
    )
    try:
        # Log a batch of conversations to BigQuery
        conversation_api_response = conversation_api_instance.ingest_conversation(
            conversation_data_schema
        )

        print("The response of ConversationApi->ingest_conversations:\n")
        pprint(conversation_api_response)

        # Log a batch of interactions to BigQuery
        interaction_api_response = interaction_api_instance.ingest_interaction(
            interaction_data_schema
        )
        print("The response of ConversationApi->ingest_interactions:\n")
        pprint(interaction_api_response)

    except ApiException as e:
        print("Exception when ingesting data: %s\n" % e)