semvec/pypi-packages huggingface dataset:
topless 0.1.0
Tailored OPerations for serverLESS
Requires Python: >=3.11,<4.0

## Action Execution Model

The Topless actionexecution model is processed in two different steps:

1. Action Handler Registration
Every action created with one of the provided decorators (route, schedule, bucket or topic) is registered on the main Topless app instance. The instance is created on the client side (main.py file), and is shared throghouth the framework modules by a singleton pattern.

Flow of execution: 
```mermaid
sequenceDiagram
    box Client
    participant C1 as bootstrap.py
    participant C2 as main.py
    end

    box Core
    participant T1 as bootstrap.py
    participant T2 as app.py
    participant T3 as handler.py
    end


    C1->>C2: Import main.py
    C2-->>C1: Topless instance and registrations
    C1->>T1: Start framework bootstrap
    T1->>T2: Load all modules
    T2->>T3: Map action handlers
    T1-->>C1: Finish setup
    
```

2. Action Handler Execution
When lambda is called, the client bootstrap.py handle method is executed. Every lambda resource on the template.yaml (dinamically generated by topless framework), will call this method at first, which will dispatch the bootstrap.handle method, to localize the action handler that is needed on that call.

```mermaid
sequenceDiagram
    participant L as Lambda Event
    participant CA as app.py (Client)
    participant CB as bootstrap.py (Client)
    participant TA as app.py (Core)
    participant TB as bootstrap.py (Core)
    participant TD as dispatcher.py (Core)
    participant TH as handler.py (Core)

    L->>CB: Trigger Lambda Function
    CB->>TB: Call framework bootstrap handler
    TB->>TD: Execute Dispatcher
    TD-->>TB: Construct action envelope and look for the correct action to be executed

```
socketcan-xcp 1.0.0
A python 3 interface to Universal Measurement and Calibration Protocol XCP
Requires Python: >=3.9

# socketcan-xcp

![coverage](https://gitlab.com/Menschel/socketcan-xcp/badges/master/coverage.svg)
![pipeline](https://gitlab.com/Menschel/socketcan-xcp/badges/master/pipeline.svg)

[Documentation](https://menschel.gitlab.io/socketcan-xcp/)

A python 3 interface to Universal Measurement and Calibration Protocol XCP

# Description

Goal of this project is to make XCP available in python in a "pythonic" way.

Keep implementation as simple as possible.
Use python3 built-in functions and bytearrays as well as standard modules like struct and enum wherever possible.

# Why yet another implementation of XCP

While there is pyxcp implementation available, it has Windows dependencies and is in general not feasible to adapt.
Instead, this XCP implementation is done from scratch in pure python.

# License
This software is distributed under GPLv3 with some extension because GPLv3 did not manage to deny
criminal misuse by organizations.
This software is intended for usage by community and private individuals who are interested in car hacking.
It is explicitly denied that any company or organization monetizes on this software. Monetize does not only mean money,
it means gaining a competitive advantage of any kind by using this software.
The author explicitly denies the usage for people associated with military,
government agencies of any kind to whatever degree, same for car manufacturers and associates.

# Deprecation of PyPi Packages
Packages on PyPi are no longer updated due to attempts of the Python Software Foundation to enforce new rules and basically flush out 
developers who do not consent.  
Recent packages can be installed directly from git, i.e.   
```pip install git+https://gitlab.com/Menschel/socketcan-xcp.git --upgrade```
hcscom 0.6.0
An interface class to manson hcs lab power supplies
Requires Python: >=3.7

# hcscom

![coverage](https://gitlab.com/Menschel/hcscom/badges/master/coverage.svg)
![pipeline](https://gitlab.com/Menschel/hcscom/badges/master/pipeline.svg)

[Documentation](https://menschel.gitlab.io/hcscom/)

A python3 class for remote control of manson hcs lab power supplies.

Manson lab power supply units can be controlled via usb.

Communication is done via a builtin CP210x usb-serial bridge and 8N1@9600 port settings.


# clones

Some PeakTech branded devices have proven to be Manson devices, i.e.

https://www.peaktech.de/productdetail/kategorie/schaltnetzteile/produkt/p-1575.html

returns `HCS-3402` as response to `GMOD` command which is

https://www.manson.com.hk/product/hcs-3402-usb/

# License
This software is distributed under GPLv3 with some the extension that it's not to be used for commercial purposes.
It is explicitly denied that any company or organization monetizes on this software. Monetize does not only mean money,
it means gaining a competitive advantage of any kind by using this software.
In addition, the author explicitly denies the usage for people associated with military and
government agencies of any kind to whatever degree.

This extension is a reaction to some blunt support request from 

Technica Engineering GmbH  
Leopoldstraße 236  
D - 80807 München

in May 2022 to basically fix problems they had during commercial usage of this software, for free.

# Deprecation of PyPi Packages
Packages on PyPi are no longer updated due to attempts of the Python Software Foundation to enforce new rules and basically flush out 
developers who do not consent.  
Recent packages can be installed directly from git, i.e.   
```pip install git+https://gitlab.com/Menschel/hcscom.git --upgrade```
opencopilot-db 6.0.0rc12
Database schemas for OpenCopilot microservices and plugins

```markdown
# opencopilot_db

`opencopilot_db` is a Python library that provides database schemas common for opencopilot main app and workers application. It defines SQLAlchemy models for working with databases, making it easy to integrate and manage your database operations.

## Installation

You can install `opencopilot_db` using pip:

```bash
pip install opencopilot_db
```

## Usage

**To create pool of connections use the following**
```py
from shared.models import create_database_schema
from dotenv import load_dotenv

import os
load_dotenv("../llm-server/.env")

create_database_schema()
```

### Importing the Models

```python
from opencopilot_db.models import PdfDataSource, Chatbot
```

### Creating and Managing Database Records

```python
# Create a PdfDataSource
pdf_data_source = PdfDataSource(chatbot_id=1, files=['file1.pdf', 'file2.pdf'], folder_name='pdf_folder')
session.add(pdf_data_source)
session.commit()

# Query PdfDataSources
pdf_data_sources = session.query(PdfDataSource).all()
for pdf_data_source in pdf_data_sources:
    print(f"PdfDataSource ID: {pdf_data_source.id}, Chatbot ID: {pdf_data_source.chatbot_id}, Files: {pdf_data_source.files}")
```

### Working with the Chatbot Model

```python
# Create a Chatbot
chatbot = Chatbot(name="My Chatbot", website="https://example.com")
session.add(chatbot)
session.commit()

# Query Chatbots
chatbots = session.query(Chatbot).all()
for chatbot in chatbots:
    print(f"Chatbot ID: {chatbot.id}, Name: {chatbot.name}, Website: {chatbot.website}")
```

## Contributing

If you'd like to contribute to `opencopilot_db`, please follow these guidelines:

1. Fork the repository.
2. Create a new branch for your feature or fix.
3. Make your changes and ensure that tests pass.
4. Submit a pull request to the `main` branch of the repository.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

- Special thanks to the SQLAlchemy project for making it easy to work with databases in Python.


## Publish guide
## Publishing Your Library

Increment the version of the library in setup.py
Use the publish script [publish.sh](./publish.sh) to publish the library
fluentpipelines 0.1.1
A Python package for building fluent pipelines
Requires Python: >=3.9

FluentPipelines
FluentPipelines is a Python package that simplifies the creation and execution of data processing pipelines.

## Features

- **Pipeline Creation**: Easily create processing pipelines by chaining together operations.
- **Flexible Operations**: Define custom operations by subclassing `PipelineOperation`.
- **Convenient Interface**: Intuitive `send`, `through`, `then`, and `then_return` methods for building and executing pipelines.
- **Error Handling**: Robust error handling for smooth pipeline execution.

```
pip install fluentpipelines
```
# Usage


### Import PyPipeline
```
from fluentpipelines import pipeline
```

### Define custom operations by subclassing PipelineOperation
```
class MyOperation(PipelineOperation):
    def process(self, data):
        # Define processing logic here
        return processed_data
```

### Create a pipeline
```
pipeline = pipeline.send(initial_data).through([MyOperation, AnotherOperation]).then_return()
```

### Custom Operations
```
class MyOperation(PipelineOperation):
    def process(self, data):
        # Define processing logic here
        return processed_data
```


## Contributing
Contributions are welcome! Feel free to open issues or submit pull requests.

## License
This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments
This package was inspired by the need for a simple and flexible data pipeline solution.