semvec/pypi-packages huggingface dataset:
lematools 0.1.0
LEMA-UFPB Tools
Requires Python: >=3.6

# LEMA TOOLS

Python packages required in productions environments


Handle development
```bash
python3 -m venv venv
source venv/bin/activate
python3 -m pip install setuptools twine
pip install .
python3 setup.py sdist
python3 -m twine upload dist/*
```
catbridge 1.0
CAT Bridge (Compounds And Transcripts Bridge) is a comprehensive longitudinal multi-omics analysis tool

# CAT Bridge: A Versatile Tool for Multi-Omics Analysis

## Overview
With advancements in sequencing and mass spectrometry technologies, multi-omics data can now be easily acquired for understanding complex biological systems. Nevertheless, substantial challenges remain in determining the association between gene-metabolite pairs  due to the complexity of cellular networks. Here, we introduce CAT Bridge (freely available at http://catbridge.work), a user-friendly platform for longitudinal multi-omics analysis to efficiently identify transcripts associated with metabolites using time-series omics data. To evaluate the association of gene-metabolite pairs, CAT Bridge incorporated a range of methods harnessing cause-and-effect relationships and similarity computation, many of which are used in omic analyses for the first time. Additionally, CAT Bridge featured an artificial intelligence (AI) assistant to assist users interpreting the assoication results. We applied  CAT Bridge to self-generated (chili pepper) and public (human) time-series transcriptome and metabolome datasets. CAT Bridge successfully identified genes involved in the biosynthesis of capsaicin in Capsicum chinense L. Furthermore, case study results showed that the convergent cross mapping (CCM) method outperforms traditional approaches in longitudinal multi-omics analyses. CAT Bridge simplifies access to various established methods for longitudinal multi-omics analysis, and enabling researchers to swiftly identify associated gene-metabolite pairs for further validation.

For more information: [Project homepage](http://catbridge.work)

## Installation
Python dependencies can be installed using pip (from the Unix terminal)
```pip install catbridge```

## Contact
The package is developed and maintained by Bowen Yang (by8@ualberta.ca). Please, reach us for problems, comments or suggestions.
fatfs 0.1.2
A wrapper around ChaN's FatFS library for FAT filesystem manipulation.
Requires Python: >=3.8

# FatFS wrapper for Python

This library provides a Python wrapper around [ChaN's FatFS](http://elm-chan.org/fsw/ff/00index_e.html) library.

Note: This package is in alpha stage. Not all features are implemented, nor is it very well tested. Use at your own risk.
logcliasst 0.1.1
Generate client-side configuration for rsyslog
Requires Python: >=3.6

# Rsyslog Configuration Generator

This Python application generates client-side configuration for rsyslog using RainerScript. The configuration includes defining a ruleset and applying it to monitor log files.

## Overview

This application provides two main functions:

1. **`client_ruleset_config`**: Generates an rsyslog RainerScript configuration string to define a ruleset with disk queue settings.
2. **`apply_ruleset_client`**: Generates an rsyslog RainerScript configuration string to apply a previously defined ruleset to monitor a log file using the imfile module.

## Prerequisites

- Python 3.x
- Basic understanding of rsyslog and RainerScript

## Functions

#### `client_ruleset_config(rule_name, server_ip, port, protocol)`

#### `apply_ruleset_client(log_file, tag, facility, severity, rule_name)`

Generates a RainerScript configuration string to define a ruleset and apply the rule.

**Arguments:**

- `rule_name` (str): Name of the ruleset.
- `server_ip` (str): IP address or hostname of the rsyslog server.
- `port` (int): Port number to send logs to.
- `protocol` (str): Protocol to use ('tcp' or 'udp').
- `log_file` (str): Log file name where the rule should be applicable.
- `tag` (str): tag of the log events.
- `facility` (str): Facilities of the log events('local0' to 'local6', 'authpriv','mail' etc.).
- `severity` (str): Log criticality('info','warn','crit' etc.).

**Returns:**

- `str`: RainerScript configuration string defining the ruleset.

**Examples:**

```python
config = client_ruleset_config("myRuleset", "192.168.1.100", 514, "tcp")
print(config)
```

```python
apply = apply_ruleset_client("/var/log/message", "message_log", "local3", "info", "myRuleset")
print(apply)
```


### `rsyslog` Configuration Template Generator

This Python script generates `rsyslog` configuration templates with TLS settings and disk queue configuration. The generated configuration can be used to securely forward logs to a remote `rsyslog` server while ensuring reliable buffering.

## Overview

The script creates an `rsyslog` configuration snippet based on user-provided parameters. This includes:
- TLS settings for secure communication.
- Disk queue settings for log buffering.

## Function: `generate_rsyslog_template`

This function generates an `rsyslog` configuration template.

### Arguments

- `cert_file` (str): Path to the CA certificate file.
- `target_host` (str): IP address or hostname of the remote `rsyslog` server.
- `protocol` (str): Protocol to use for communication (e.g., `tcp`).
- `port` (str): Port number on the remote server.
- `rule_name` (str): Name of the ruleset.


### Returns

- `str`: The generated `rsyslog` configuration template as a string.
#### Usage:
#### `client_tls_template(cert_file, target_host, protocol, port, rule_name)`
bibdatamanagement 1.0.5
Package to read .bib file annotations and retrieve values from it
Requires Python: >=3.6

# Bibliography management

The goal is to provide an easy way to extract in python custom data set in the *annote* field of a bib file.

## Installation

**BibdataManagement** library is stored in IPESE pypi server located on https://ipese-internal.epfl.ch/registry/pypi. and https://pypi.org/project/bibdatamanagement/

To include the library in your projects, do the following in _requirements.txt_:
1. Include the package 
```
bibdatamanagement >= 0.6.0
```

Otherwise, the package can be installed by using a _pip_ command.  
```
pip install bibdatamanagement
```

## Data format

The package is designed to extract data in a specific format. The initial development was made for technologies parameter
used to model it.
```
+- ENTRY # row_key:set: general description of tech
param1 = min:value1:max [unit1] # short_name: a comment about the param and its value
param2 = value2 [unit2]
+- /ENTRY
```
Where the fields described as follows:
|Fields | Description | Mandatory|
|--- | --- | ---|
|ENTRY | The name of the tech to which the parameters belong | True|
|row_key | An identifier | False|
|set | Use to retrieve all values from a user (e.g. all values for   *scenario_oil*) | False|
|general_description | A comment on the tech or on the paper | False|
|param | Name of the parameter characterised | False|
|value | Value of the parameter | True|
|min | Minimal value that the parameter can have | False|
|max | Maximal value that the parameter can have | False|
|unit | Unit of the parameter | True|

The minimal information to provide is the `+- ENTRY       +- /ENTRY`. The fields after the _#_ are optional, as well as
the min and max values.

> Nb: spaces in the key/value line are for readability but are not required

## Usage

The minimal workflow to access the data in the _.bib_ is the following.

```python
from bibdata_management.bibdata_management import BibDataManagement
bib_file = 'your_path/your_file.bib'
bibdata = BibDataManagement(bib_file)
df_bib = bibdata.get_data(tech_name='YOUR_ENTRY', set_name='YOUR_SET')
```

One can also add a _.csv_ file that contains the default value for parameters description (short name, long name, description).
```{python}
bibdata = BibDataManagement(bib_file, 'your_default_file.csv')
```

## Documentation

More information on the fields and the methods is available in the [documentation website](https://bibdata.readthedocs.io/en/latest/)

## Suggestions and contributions

All suggestions or implementation must be tracked with dedicated issues and reported at the [project GitHub](https://github.com/IPESE/BibDataManagement/issues) 

If you want to make the format evolve or implement a new python function, create an issue before anything else.

## Author

- [Joseph Loustau](mailto:joseph.loustau@gmail.com), IPESE
almax-common 1.0.7.dev20240801212517
Library with my most used Classes and Methods

# AlmaxClasses
Generic Purpose Classes

# AlmaxGraphics
Everything i use to create graphics for Desktop apps or other needs

# AlmaxLogs
Logging services

# AlmaxSystemManagment
Some Utils you can use to manage Subprocesses or Threads

# AlmaxUtils
Utility functions for any purpose
shipyard-excel 0.2.0a0
A local client for working with Excel files in Microsoft OneDrive
Requires Python: <4.0,>=3.9

# shipyard-excel

## Overview 

`shipyard-excel` is a Python package that provides a client for interacting with Excel files stored in Microsoft OneDrive. This package leverages the Microsoft Graph API to perform various operations on Excel spreadsheets, such as retrieving sheet IDs and fetching sheet data.



### Features 
- Authentication using client credentials flow
- Fetch Sheet Data 
- Convert Sheet Data to DataFrame

The `ExcelClient` inherits from the `OneDriveClient`, meaning that all the methods defined there (upload, download, move, remove) are 
also available in this package.

### Installation 

To install the package, run the following command:
```bash
python3 -m pip install shipyard-excel
```

## Usage 

### Initialization 
To use the ExcelClient, you need to initialize it with your client credentials and user email:

```python 
from shipyard_excel import ExcelClient

client_id = 'your_client_id'
client_secret = 'your_client_secret'
tenant_id = 'your_tenant_id'
user_email = 'your_user_email'

excel_client = ExcelClient(client_id, client_secret, tenant_id, user_email)

excel_client.connect()
```


### Get Sheet Data as a DataFrame

```python 
# get the sheet ID, drive ID, and file ID
user_id = excel_client.get_user_id()
drive_id = excel_client.get_drive_id(user_id)
file_id = excel_client.get_file_id("<file_name.xlsx>", drive_id)
sheet_id = excel_client.get_sheet_id("<Sheet Name>", file_id, drive_id)

df = excel_client.get_sheet_data_as_df(file_id, sheet_id, drive_id)

print(df.head())

```
MH410D 1.0.0
MH410D CO2 UART/V out 0-10.00% VOL Sensor.
Requires Python: >=3.6



# MH410D by NekoSensors

A Python library for interfacing with the MH-410D CO2 sensor via UART.

Sensor Datasheet (+ Protocol) - [MH-410D.PDF](docs%2FMH-410D.PDF)

![image.png](__assets__%2Fimage.png)

## Installation

You can install the library via pip:

```bash
pip install MH410D
```

## Usage

Here is an example of how to use the `MH410D` library:

```python
from MH410D import MH410D_CO2

# Create an instance of the sensor
sensor = MH410D_CO2(port='COM3', baudrate=9600, timeout=2)

# Read gas concentration
concentration_ppm = sensor.read_gas_concentration()
if concentration_ppm is not None:
    print(f"Gas concentration: {concentration_ppm} ppm")
    print(f"Gas concentration: {sensor.ppm_to_percent(concentration_ppm)} %")

    # Example conversion to mg/m3 for carbon dioxide (CO2), molar mass 44 g/mol
    concentration_mg_m3 = sensor.ppm_to_mg_m3(concentration_ppm, molar_mass=44)
    print(f"Gas concentration: {concentration_mg_m3} mg/m3")

# Calibrate the sensor
sensor.calibrate_zero()
sensor.calibrate_span()

# Close the connection
sensor.close()
```

## Features

- **Read Gas Concentration**: Read CO2 concentration in ppm from the MH-410D sensor.
- **Calibrate Sensor**: Calibrate the zero and span points of the sensor.
- **Convert Units**: Convert gas concentration from ppm to percentage and mg/m3.

## API Reference

### `MH410D_CO2`

#### `__init__(self, port='COM3', baudrate=9600, timeout=2)`

Initializes the serial connection with the specified parameters.

- `port` (str): Port name to which the sensor is connected (default 'COM3').
- `baudrate` (int): Data transmission speed (default 9600).
- `timeout` (int): Timeout for read operations (default 2 seconds).

#### `read_gas_concentration(self)`

Sends a command to read gas concentration and returns the value.

- **Returns**: Gas concentration in ppm, or `None` if reading failed.

#### `calibrate_zero(self)`

Sends a command to calibrate the sensor zero point.

- **Returns**: `True` if calibration is successful, otherwise `False`.

#### `calibrate_span(self)`

Sends a command to calibrate the sensor span point.

- **Returns**: `True` if calibration is successful, otherwise `False`.

#### `ppm_to_percent(self, ppm)`

Converts ppm to percentage.

- `ppm` (int): Value in ppm.
- **Returns**: Value in percentage.

#### `ppm_to_mg_m3(self, ppm, molar_mass, temperature=25, pressure=101325)`

Converts ppm to mg/m3.

- `ppm` (int): Value in ppm.
- `molar_mass` (float): Molar mass of the gas in grams per mole.
- `temperature` (float): Temperature in degrees Celsius (default 25).
- `pressure` (float): Pressure in Pascals (default 101325 Pa).
- **Returns**: Value in mg/m3.

#### `close(self)`

Closes the serial connection.


### Out Another Projects:

https://github.com/NekoRMD/NekoRMD - Control MyActuator RMD X8-PRO using Python by CAN

https://github.com/K-Lab-Students/REIS_PCB - PBC library
shipyard-microsoft-onedrive 0.2.0
A local client for working with files in Microsoft OneDrive
Requires Python: <4.0,>=3.9

# OneDriveClient README

## Overview

`OneDriveClient` is a Python class that provides a simple interface for interacting with Microsoft OneDrive using the Microsoft Graph API. This class allows you to connect to OneDrive, upload and download files, move or rename files, and manage folders and files within a OneDrive account.

## Installation

To use the `OneDriveClient` class, you need to install:

```bash
python3 -m pip install shipyard-microsoft-onedrive
```


## Usage
#### Initialization
Create an instance of the OneDriveClient class by providing your client ID, client secret, tenant ID, and optionally, a user email.

```python 
from OneDriveClient import OneDriveClient

client = OneDriveClient(
    client_id='your_client_id',
    client_secret='your_client_secret',
    tenant='your_tenant_id',
    user_email='user_email@example.com'
)
```
#### Connecting to OneDrive 
Connect to OneDrive using the connect method. This method will acquire an access token using client credentials.
```python
client.connect()
```

#### Getting User and Drive ID
To obtain the user and drive ID associated with the credentials, run the following:
```python 
user_id = client.get_user_id()
drive_id = client.get_drive_id(user_id)
```

### Common Methods 

##### Uploading Files 
Upload a file to OneDrive using the upload method. Specify the local file path, drive ID, and the path in OneDrive where the file should be uploaded.
```python
client.upload(file_path='path/to/local/file', drive_path='path/in/onedrive', drive_id=drive_id)
```

##### Downloading Files
Download a file from OneDrive using the download method. Provide the local file path to save the file, the path in OneDrive, and the drive ID.
```python
client.download(file_path='path/to/save/file', drive_path='path/in/onedrive', drive_id=drive_id)
```

##### Moving/Renaming Files in OneDrive
Move or rename a file in OneDrive using the move method. Specify the source name, source directory, target name, target directory, and drive ID.

```python 
client.move(src_name='source_file_name', src_dir='source_directory', target_name='new_file_name', target_dir='target_directory', drive_id=drive_id)
```


##### Removing Files in OneDrive 
Remove a file from OneDrive using the remove method. Provide the path in OneDrive and the drive ID.

```python
client.remove(drive_path='path/in/onedrive', drive_id=drive_id)
```