semvec/pypi-packages huggingface dataset:
seaway 1.1.4
客户端组件化CLI
License: MIT
Keywords: 组件化

SeawayCli

## 1. 安装

### 1.1. python3环境安装

brew install python3


### 1.2. seaway安装

pip3 install seaway

## 2. 使用

### 2.1. 初始化APP壳工程

```
seaway init app
```

* 在工程目录下运行 
* 初始化成功后在gradle.properties配置你的信息
    ```
    #seaway config
    seaway.depRepo=请填写依赖git地址
    seaway.versionName=请填写APP版本名
    seaway.versionCode=请填写APP版本号
    seaway.appName=请填写APP名
    seaway.useLocalDependencies=false
    seaway.hostApp=true
    ```

### 2.2. 初始化组件壳工程
```
seaway init mp
```

* 在工程目录下运行 seaway init mp
* 初始化成功后在gradle.properties配置你的信息
    ```
    #seaway config
    seaway.depRepo=请填写依赖git地址
    ```

### 2.3. 初始化组件模块
```
seaway init module
  -dir , --dirPath   组件工程路径(默认命令运行目录)
  -g , --group       maven group
  -a , --artifact    maven artifact
```
* 可以指定group和artifact 
    ```
    seaway init module -g group -a artifact
    ```

* 可以交互式输入group和artifact 
    ```
    seaway init module
    ```


* 初始化成功后在模块的nexus.properties确认你的信息
    ```
    nexus_groupId=123
    nexus_artifactId=123
    ```

## 3. 变更日志
请查看 [变更日志](CHANGELOG.md) 了解详细版本更新信息。
sequence-label 0.1.8
A Tensor Creation and Label Reconstruction for Sequence Labeling
License: MIT
Requires Python: <3.14,>=3.10

# sequence-label

`sequence-label` is a Python library that streamlines the process of creating tensors for sequence labels and reconstructing sequence labels data from tensors. Whether you're working on named entity recognition, part-of-speech tagging, or any other sequence labeling task, this library offers a convenient utility to simplify your workflow.

## Basic Usage

Import the necessary dependencies:

```py
from transformers import AutoTokenizer

from sequence_label import LabelSet, SequenceLabel
from sequence_label.transformers import create_alignments
```

Start by creating sequence labels using the `SequenceLabel.from_dict` method. Define your text and associated labels:

```py
text1 = "Tokyo is the capital of Japan."
label1 = SequenceLabel.from_dict(
    tags=[
        {"start": 0, "end": 5, "label": "LOC"},
        {"start": 24, "end": 29, "label": "LOC"},
    ],
    size=len(text1),
)

text2 = "The Monster Naoya Inoue is the who's who of boxing."
label2 = SequenceLabel.from_dict(
    tags=[{"start": 12, "end": 23, "label": "PER"}],
    size=len(text2),
)

texts = [text1, text2]
labels = [label1, label2]
```

Next, tokenize your `texts` and create the `alignments` using the `create_alignments` method. `alignments` is a tuple of instances of `LabelAlignment` that aligns sequence labels with the tokenized result:

```py
tokenizer = AutoTokenizer.from_pretrained("roberta-base")
batch_encoding = tokenizer(texts)

alignments = create_alignments(
    batch_encoding=batch_encoding,
    lengths=list(map(len, texts)),
    padding_token=tokenizer.pad_token
)
```

Now, create a `label_set` that will allow you to create tensors from sequence labels and reconstruct sequence labels from tensors. Use the `label_set.encode_to_tag_indices` method to create `tag_indices`:

```py
label_set = LabelSet(
    labels={"ORG", "LOC", "PER", "MISC"},
    padding_index=-1,
)

tag_indices = label_set.encode_to_tag_indices(
    labels=labels,
    alignments=alignments,
)
```

Finally, use the `label_set.decode` method to reconstruct the sequence labels from `tag_indices` and `alignments`:

```py
labels2 = label_set.decode(
    tag_indices=tag_indices, alignments=alignments,
)

assert labels == labels2
```

## Installation

```
pip install sequence-label
```
callbacker 0.1.0
Callback library for sync/async python
License: MIT
Requires Python: >=3.11

# Callbacker

Callbacker is a lightweight and flexible callback library for both synchronous and asynchronous Python programming. It provides a simple yet powerful way to implement event-driven programming patterns in Python.

## Features

- Support for both synchronous and asynchronous callbacks
- Decorator-based event registration
- Type-safe event handling
- Easy to integrate with existing codebases
- Minimal dependencies (only requires `frozenlist`)
- Python 3.11+ support
- Thread-safe event dispatching

## Installation

You can install Callbacker using PDM:

```sh
pip callbacker
```

## Quick Start

Here's a simple example of how to use Callbacker:

```python
from callbacker.callback import EventWrapper

# Create an event
custom_event = EventWrapper()

# Register a callback using decorator syntax
@custom_event
async def on_event(data):
    print(f"Received event with data: {data}")

# Trigger the event asynchronously
await custom_event.aio_send("Hello, World!")
```

## Advanced Usage

### Class-based Events

```python
from callbacker.callback import event, contextevent

class MyClass:
    @event
    async def on_data(self, data):
        """This is a regular event"""
        print(f"Received data: {data}")

    @contextevent
    async def on_update(self, context, data):
        """This event includes the class instance as context"""
        print(f"Update from {context} with data: {data}")
```

### Synchronous Callbacks

```python
from callbacker.callback import EventWrapper

event = EventWrapper()

@event
def sync_handler(data):
    print(f"Handling {data} synchronously")

# Trigger synchronously
event.send("test data")
```

## Documentation

For more detailed documentation and examples, please visit [the documentation page](https://github.com/ipfans/callbacker).

## Contributing

Contributions are welcome! Please read our [Contributing Guidelines](CONTRIBUTING.md) for details on how to submit pull requests, report issues, and contribute to the project.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
ki2-mqtt-viewer 1.0.1
MQTT Viewer is a user-friendly application designed to help users interact with MQTT brokers effortlessly. With an intuitive interface, it allows users to connect to an MQTT server, view and log messages for different topics, and publish messages with ease.
License: MIT
Requires Python: <3.14,>=3.10

# MQTT Viewer

MQTT Viewer is a user-friendly application designed to help users interact with MQTT brokers effortlessly. With an intuitive interface, it allows users to connect to an MQTT server, view and log messages for different topics, and publish messages with ease.

## Features

- **Connect to MQTT Brokers**:

  - Enter the server address, port, and optional authentication details.
  - Save and load connection profiles for future use.

- **Manage Topics**:

  - Topics are automatically added as messages are received.
  - View a list of available topics.
  - Add custom topics manually.

- **Message Logging**:

  - View incoming and outgoing messages for selected topics.
  - Messages are color-coded for clarity.

- **Send Messages**:

  - Compose and send messages to any topic.

## Installation

### Step 1: Install the Application

1. Open a terminal on your system.
2. Run the following command to install MQTT Viewer using `pip`:
   ```bash
   pip install ki2-mqtt-viewer
   ```

### Step 2: Run the Application

1. After installation, launch the application by typing:
   ```bash
   mqtt-viewer
   ```
2. The graphical interface will open, allowing you to connect to your MQTT broker.

## Usage

1. **Launch the Application**:
   Run the command `mqtt-viewer` in your terminal to start the application.

2. **Connect to an MQTT Broker**:

   - Enter the server address (default: `localhost`) and port (default: `1883`).
   - If the broker requires authentication, check the box and provide your username and password.
   - Click **Connect** to establish a connection.

3. **Save a Connection Profile**:

   - After entering your connection details, click **Save Profile** to store them for future use.
   - Use **Load Profile** to quickly reconnect.

4. **View Topics and Messages**:

   - Once connected, topics will be automatically added as messages are received.
   - Browse the list of topics and click a topic to view its message log.

5. **Send a Message**:

   - Select a topic from the list or add one manually if necessary.
   - Enter your message in the input field and click **Send**.

## License

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