semvec/pypi-packages huggingface dataset:
neuronexpert 1.0.2
This is the lib to use Neuron Expert Assistant
Requires Python: >=3.6
Keywords: neuron expert

```markdown
# Neuron Chat Client

This is a Python client library for interacting with the Neuron chat API. It allows you to easily send messages to the API and receive responses.

## Installation

You can install the library using pip:

```bash
pip install neuronexpert
```

## Usage

Here is an example of how to use the `Neuron` class to interact with the Neuron chat API:

### Basic Usage

First, import the `Neuron` class and create an instance of it with your `chat_id` and `api_key`.

```python
from neuronexpert import Neuron

# Initialize the Neuron client
client = Neuron(chat_id=12345, api_key='your-api-key')

# Ask a question
answer = client.ask("Hello, how are you?")
print(answer)
```

### Detailed Example

Here is a more detailed example demonstrating how to handle errors and format the response:

```python
from neuronexpert import Neuron

def main():
    # Replace with your actual chat_id and API key
    chat_id = 12345
    api_key = 'your-api-key'
    
    # Initialize the Neuron client
    client = Neuron(chat_id=chat_id, api_key=api_key)
    
    # Ask a question
    question = "What is the weather like today?"
    
    try:
        # Get the answer from the Neuron API
        answer = client.ask(question)
        print(f"Question: {question}")
        print(f"Answer: {answer}")
    except Exception as e:
        print(f"An error occurred: {e}")

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

### Class Documentation

#### `Neuron` Class

**Initialization**:

```python
client = Neuron(chat_id: int, api_key: str)
```

- `chat_id`: The ID of the chat session.
- `api_key`: Your API key for accessing the Neuron chat API.

**Methods**:

- `ask(message: str) -> str`: Sends a message to the Neuron chat API and returns the response.
  - `message`: The message you want to send to the API.

### Error Handling

The `ask` method includes error handling for various types of errors that might occur during the request. If an error occurs, it will be printed to the console.

### Dependencies

This library depends on `aiohttp` for making asynchronous HTTP requests. The dependency is listed in `setup.py` and will be installed automatically when you install the package.

## Development

If you want to contribute to the development of this library, you can clone the repository and install the dependencies:

```bash
git clone https://github.com/nnevdokimov/neuronexpert.git
cd neuronexpert
pip install -r requirements.txt
```

## License

This project is licensed under the MIT License. See the `LICENSE` file for more details.

---

Feel free to customize the examples and usage instructions to better fit your needs. If you encounter any issues or have suggestions for improvements, please open an issue or submit a pull request on GitHub.

```
coverage-lcov 0.3.0
A simple .coverage to LCOV converter
Requires Python: <4.0.0,>=3.6.3
Keywords: coverage

# coverage-lcov

`coverage-lcov` is a simple CLI for converting `.coverage` files generated by [Coverage.py](https://github.com/nedbat/coveragepy) to the `LCOV` format.

## Credits

- This tools is based on code from [Coverage.py](https://github.com/nedbat/coveragepy/blob/master/coverage/report.py)
- This tool is forked from [coveragepy-lcov](https://github.com/chaychoong/coveragepy-lcov) by [Chay Choong](https://github.com/chaychoong) to add support for older python versions.

## Installation

Using pip:

```bash
pip install coverage-lcov
```

## Usage

```bash
# If the .coverage file is in your current working directory
coverage-lcov

# Point to a different .coverage file path
coverage-lcov --data_file_path example/.coverage

# Write the output to a different file path
coverage-lcov --output_file_path build/lcov.info

# Use relative paths in the LCOV output
coverage-lcov --relative_path
```

## Options

```text
Usage: coverage-lcov [OPTIONS]

Options:
  --data_file_path TEXT    Path to .coverage file
  --output_file_path TEXT  lcov.info output file path
  --config_file TEXT       Path to .coveragerc file
  --relative_path          Use relative path in LCOV output
  --preview                Preview LCOV output
  --help                   Show this message and exit.
```

## Further reading

- [LCOV format](http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php)
- https://github.com/nedbat/coveragepy/issues/587
- https://github.com/chaychoong/coveragepy-lcov
sopel-modules.chanlogs 0.2.3.post0
A channel logging plugin for Sopel (replaced)

# sopel-chanlogs
A channel logging plugin for Sopel IRC bots

**This package no longer receives updates. Please upgrade to Sopel 8.0+ and
[`sopel-chanlogs`][new-chanlogs] when you are able to do so.**

[new-chanlogs]: https://pypi.org/project/sopel-chanlogs/

## Requirements

`sopel-chanlogs` requires only Sopel 7.x itself.

## Usage

Install the package from PyPI:

    pip install sopel-modules.chanlogs

Enable with the `sopel-plugins enable chanlogs` command, if your bot
configuration requires it.

### Configuration

All settings are optional, falling back on sensible defaults.

<dl>
  <dt>
    <tt>dir</tt>
  </dt>
  <dd>
    Path to channel log storage directory. Default: <tt>~/chanlogs</tt>
  </dd>
  <dt>
    <tt>by_day</tt>
  </dt>
  <dd>
    Split log files by day. Default: <tt>True</tt>
  </dd>
  <dt>
    <tt>privmsg</tt>
  </dt>
  <dd>
    Record private messages. Default: <tt>False</tt>
  </dd>
  <dt>
    <tt>microseconds</tt>
  </dt>
  <dd>
    Include microseconds in log timestamps. Default: <tt>False</tt>
  </dd>
  <dt>
    <tt>localtime</tt>
  </dt>
  <dd>
    <p>
      Attempt to use preferred timezone (the bot's
      <tt>core.default_timezone</tt>) instead of UTC. Default: <tt>False</tt>
    </p>
    <p>
      <em>
        <strong>Please note</strong> that Sopel's default
        <tt>default_timezone</tt> is UTC.
      </em>
    </p>
  </dd>
</dl>

#### Advanced configuration

Log line templates can be overridden using the relevant setting from this list:

- `message_template`
- `action_template`
- `join_template`
- `part_template`
- `quit_template`
- `nick_template`
- `topic_template`

Each template is formatted using the following `{placeholder}` values:

- the `trigger`, with all of its attributes (see [Sopel's
  documentation](https://sopel.chat/docs/trigger.html))
- the `date` in ISO format
- the `time` in ISO format
- the full `datetime` in ISO format

For convenience, the `message_template` also receives a `message` placeholder.

Please consult the plugin's code for current default templates.
umami-asgi 0.2.0
A middleware for your ASGI application that enables Umami analytics.
Requires Python: >=3.8
Keywords: analytics, asgi, asgi-middleware, metrics, middleware

# ASGI Middleware for Umami Analytics

This project provides a middleware for your
[ASGI-compatible](https://asgi.readthedocs.io/en/latest/introduction.html) app
(e.g. FastAPI, Starlette) that automatically sends access events to your
[umami](https://umami.is/) instance. If you want to track your API clients
in a GDPR-friendly way, then this middleware is for you.

## Usage

For this middleware, you need the following information:

- The URL of your Umami API (e.g. `https://umami.example.com/api`
- The website GUID (e.g. `12345678-1234-1234-1234-123456789012`)

Install the package via pip:

```bash
pip install umami-asgi
```

Then, you can add the umami middleware to your ASGI app. Here is an example for
FastAPI:

```python
from fastapi import FastAPI
from umami_asgi import UmamiMiddleware

app = FastAPI()
app.add_middleware(
    UmamiMiddleware,
    api_url="https://umami.example.com/api",
    website_id="12345678-1234-1234-1234-123456789012"
)
```

For more extensive examples, see the `examples` directory.

## Try it out

In the `examples` directory, you can find examples for FastAPI and Starlette
that you can try out easily. First, create a `.env` file in the `examples`
directory with the following content:

```text
UMAMI_API_ENDPOINT="https://example.com/api"
UMAMI_SITE_ID="your-site-id"
```

Then, install the necessary dependencies and run the example:

```bash
pip install uvicorn python-dotenv fastapi starlette 

# FastAPI:
python -m uvicorn examples.fastapi_app:app --env-file examples/.env

# Starlette:
python -m uvicorn examples.starlette_app:app --env-file examples/.env
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
for details.
FenixRefO 0.13.1
Regular expressions for objects
Requires Python: <4.0,>=3.8
Keywords: regular expressions, regexp, re, objects, classes

REfO
====

Lacking a proper name, REfO stands for "Regular Expressions for Objects".

It's a python library that supplies a functionality very similar to the python
`re` module (regular expressions) but for arbitrary sequences of objects
instead of strings (sequences of characters).

In addition to that, it's possible to match each object in a sequence with
not only equality, but an arbitrary python function.
For example, if you have a sequence of integers you can make a regular
expression that asks for a even number followed by a prime number
followed by a 3-divisible number.

This software was written by Rafael Carrascosa while working at Machinalis in
the first months of 2012.

Contact: rcarrascosa@machinalis.com
or rafacarrascosa xyz gmail.com (replace " xyz " with "@")

[![Build Status](https://travis-ci.org/gjhiggins/refo.png?branch=master)](https://travis-ci.org/gjhiggins/refo)

How to use it
-------------

The syntax is a little bit different than python's re, and similar to that of
pyparsing, you have to more-or-less explicitly build the syntax tree of
your regular expression. For instance:

`"ab"` is `Literal("a") + Literal("b")`

`"a*"` is `Star(Literal("a"))`

`"(ab)+|(bb)*?"` is:

    a = Literal("a")
    b = Literal("b")
    regex = Plus(a + b) | Star(b + b, greedy=False)

You can also assign a group to any sub-match and later on retrieve the matched
content, for instance:

    regex = Group(Plus(a + b), "foobar")  | (b + b)
    m = match(regex, "abab")
    print m.span("foobar")  # prints (0, 4)

For more, check out the examples in the examples folder.


How we use it
-------------

At Machinalis we use REfO for applications similar to that in
`examples/words.py`, check it out!


About the implementation
------------------------

I use a Thompson-like virtual machine aproach, which ensures polynomial time
worst-case complexity. See `examples/poly_time.py` for an example of this.

The implementation is heavily based on Russ Cox notes, see
http://swtch.com/~rsc/regexp/regexp2.html for the source.

If you go to read the code, some glossary:

 - RE  --  regular expression
 - VM  --  virtual machine
 - Epsilon transitions  --  All VM instructions that do not consume a symbol
                            or stop the thread (for example an Accept).


Acknowledgements
----------------

Thanks Russ Cox for sharing the awesome info and insights on your web site.

Thanks Javier Mansilla for reviewing the code and being enthusiastic about it.

Thanks Machinalis for everything :)