semvec/pypi-packages huggingface dataset:
nextcloudtalkbot 0.0.46
Python3 library for creating a Nextcloud Talk bot.
Requires Python: >=3.7
Keywords: bot,nextcloud,nextcloud talk

# Nextcloud Talk Bot

Python 3 library for creating a Nextcloud Talk bot. 

This repository contains the code for a Nextcloud Talk bot that can perform various actions in a Nextcloud Talk room, such as sending files and listing activities.

## Installation

Via PIP:

```
pip install nextcloudtalkbot
```

or manually:

Clone this repository:

```
git clone https://github.com/sowoi/nextcloud-talk-bot.git
```

## NLP

To use Spacy as a Natural Language Processor, it is necessary to download a model.

```
python -m spacy download en_core_web_sm
```
The command downloads the model for the English language file. 


## Documentation

Documentation can be found at [readthedocs.org](https://nextcloud-talk-bot.readthedocs.io).

## Translations

This project uses [Hosted Weblate](https://hosted.weblate.org/engage/nextcloudtalkbot/) for translation.


## License

Licensed under the terms of GNU General Public License v3.0. See LICENSE file.


## Developer-Website

[https://okxo.de](https://okxo.de)


![Linting](https://github.com/sowoi/nextcloud-talk-bot//actions/workflows/python-lint.yml/badge.svg)
![Unittests](https://github.com/sowoi/nextcloud-talk-bot//actions/workflows/python-tox.yml/badge.svg)
[![CodeQL](https://github.com/sowoi/nextcloud-talk-bot/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/sowoi/nextcloud-talk-bot/actions/workflows/github-code-scanning/codeql)
![License](https://img.shields.io/pypi/l/nextcloudtalkbot?style=plastic)
![Dependencies](https://img.shields.io/librariesio/github/sowoi/nextcloud-talk-bot?style=plastic)
![Versions](https://img.shields.io/pypi/pyversions/nextcloudtalkbot?style=plastic)
![Release](https://img.shields.io/pypi/status/nextcloudtalkbot?style=plastic)
![Docs](https://readthedocs.org/projects/nextcloud-talk-bot/badge/?version=latest&style=plactic)
![Translations](https://hosted.weblate.org/widgets/nextcloudtalkbot/-/svg-badge.svg)
bp-data-visualization 1.0.5
Show data in charts
Requires Python: >=3.8.10

# Data Visualization

**Data Visualization** is a Python package that provides a Streamlit component for easy and interactive data visualization. This component allows you to create beautiful and insightful visualizations with just a few lines of code.

## Features

- **Chart Variety**: Utilize a wide range of chart types, including bar charts, pie charts, scatter charts, and heatmaps, to effectively convey data insights.
- **Export Options**: Export charts as SVG, PNG, or PDF files, allowing for seamless integration into various platforms and documents.
- **Chart Configuration**: Customize charts by adjusting parameters such as color schemes, labels, axes, and legends to specific requirements.

## Installation

You can install the **Data Visualization** package from PyPI using pip:

```shell
pip install bp-data-visualization
```

## Usage

To use the Data Visualization component in your Streamlit application, follow these steps:

1. Import the necessary modules:

```shell
import data_visualization as dv
```

1. Add the **Data Visualization** component to your application:

```shell
dv.data_visualizer(
    title=title,
    data=data,
    key="data_visualizer",
)
```

1. Run your Streamlit application:

```shell
streamlit run your_app.py
```

### Example

```shell
import data_visualization as dv

data = [
    {"id": 1, "lastName": "Snow", "firstName": "Jon", "age": 35},
    {"id": 2, "lastName": "Lannister", "firstName": "Cersei", "age": 42},
    {"id": 3, "lastName": "Lannister", "firstName": "Jaime", "age": 45},
    {"id": 4, "lastName": "Stark", "firstName": "Arya", "age": 16},
    {"id": 5, "lastName": "Targaryen", "firstName": "Daenerys", "age": 90},
    {"id": 6, "lastName": "Melisandre", "firstName": "Tom", "age": 150},
    {"id": 7, "lastName": "Clifford", "firstName": "Ferrara", "age": 44},
    {"id": 8, "lastName": "Frances", "firstName": "Rossini", "age": 36},
    {"id": 9, "lastName": "Roxie", "firstName": "Harvey", "age": 65},
]

dv.data_visualizer(
     title="Data Visualization",
     data=data,
     key="data_visualizer",
)

```

## Screenshot

![Screenshot](https://i.ibb.co/PWpGN3K/Visuals.png "Screen Shot")
permmod 0.3
A package to calculate the permeability of rock samples
Requires Python: >=3.11

# permmod

## What is it?

permmod is a Python package that is used to calculate the permeability of two-chamber-method measurements.
This type of measurement is based on Brace's pulse decay method and extends it to include pressure- and 
temperature-dependent material parameters. More details are available in the following paper.

## How to use it.

In order to use the package there must be a measurement-, a database- and a measurement_units-file in the following 
folder structure:
```
Measurements
│   database.csv
│   measurement_units.csv   
│
└───raw_data
│   │   measurement_file1.txt
│   │   ...
│   
└───sim_data
│   │   ...
│   
└───pics
│   │   ...
```

An example of the structure of the folders and the 3 files is given in the **example folder**. 

To evaluate a measurement, you can proceed as follows:
```sh
from permmod import Measurement

path = 'raw_data/measurement_file1.txt'
measurement = Measurement(path=path)
measurement.calculate_permeability([1e-19, 0.001], parameter='both')
```
For more information see the documentation

## Installation
The source code is hosted on GitHub at:
https://github.com/kirchma/permmod

Binary installers for the latest released version are available at the [Python
Package Index (PyPI)](https://pypi.org/project/permmod/)

```sh
# PyPI
pip install permmod
```
cveutils 0.6
This library provides functionality for fetching and parsing information about Common Vulnerabilities and Exposures (CVE) using the NIST National Vulnerability Database (NVD) RESTful API.

# cveutils
![logo](https://raw.githubusercontent.com/viniciuspereiras/cveutils/main/static/logo.png)

[![PyPI](https://img.shields.io/pypi/v/cveutils?style=flat)](https://pypi.python.org/pypi/cveutils/)
[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://choosealicense.com/licenses/mit/)

This library provides functionality for fetching and parsing information about Common Vulnerabilities and Exposures (CVE) using the NIST National Vulnerability Database (NVD) RESTful API.
## Instalation
```bash
pip install cveutils
```
## Usage
To use this library, simply import the CVE class and initialize an instance with a CVE ID as a string.

```python

from cveutils import CVE

cve = CVE('CVE-2021-12345')
```
### CVE Object

The `CVE` object has the following attributes:
- `ID`: The CVE ID
- `info`: The full JSON response from the NVD API for the given CVE ID
- `description`: The description of the CVE
- `cvss_v2`: A dictionary containing the CVSSv2 score and related metrics (if available)
- `cvss_v3`: A dictionary containing the CVSSv3 score and related metrics (if available)
- `published_date`: The published date of the CVE in ISO format (YYYY-MM-DD)
- `last_modified_date`: The last modified date of the CVE in ISO format (YYYY-MM-DD)
- `assigner`: The organization that assigned the CVE ID
- `references`: A list of references related to the CVE

The `cvss_v2` and `cvss_v3` attributes are instances of the CVSSDictionary class, which allows access to the dictionary keys as attributes.
# Example Usage

```python

from cveutils import CVE

cve = CVE('CVE-2021-12345')

print(cve.ID)
print(cve.description)
print(cve.cvss_v3.baseScore)
print(cve.published_date)
print(cve.last_modified_date)
print(cve.assigner)
print(cve.references)
```
Output:
```css

CVE-2021-12345
Description of the vulnerability
7.8
2021-01-01
2021-02-01
MITRE
['https://example.com/reference1', 'https://example.com/reference2']

```
CreateAI 0.10.0
Easy tool for creating AI in python
Requires Python: >=3.6


# CreateAI v0.9.5
It's easy tool to create ai in python easy and fast.
You can edit source code of CreateAI on [Create AI's github](https://github.com/R0fael/CreateAI)

## Dependencies
 - numpy
 - knowledge of python
 - our documentation
 - your motivation
 - your brain

## Authors

 - [@R0fael](https://www.github.com/R0fael) - main programmer

## Features
 - Custom function activations - Errors
 - Neuron creating in one line of code
 - absolutly open sourse

## Installation

Installing project with pip

Windows:
```bash
pip install СreateAI
```

MacOS:
```bash
pip3 install СreateAI
```

Linux:
```bash
sudo pip install СreateAI
```

Or if you don't have pip :
download sourse code and editing examples files

## Example
```python
from CreateAI import *
"""
inputs - create inputs
outputs - create outputs
"""
# importing CreateAI
from CreateAI import *

n = Neuron(weights(3, 1), inputs([
    [0, 0, 1],
    [1, 1, 1],
    [1, 0, 1],
    [0, 1, 1]
]), outputs([[0, 1, 1, 0]]),save_path="my_save.nws")  # Neuron creating with saving
#.nws -> file extension -> neuron weight save

n.learn(20_000)  # Neuron learning

print(n.process([1, 1, 0]))  # Neuron test
print(n.process([0, 1, 0]))  # Neuron test
```

## Change log
-0.8 - First version

-0.8.1 - Little bug fix

-0.9.2 - Speed up

-0.9.3 - Bug Fix

-0.9.4 - Bug Fix of bug fix

-0.9.5 - convertors

## Plans
-0.10.0 - Saving system

-0.10.1 - Fixing custom functions activation

-0.10.2 - Multi neurons update

-0.11.0 - More metods of learning
play-poker 0.1.2
Command Line Single-player game of Texas Hold'Em poker
Requires Python: >=3.9
Keywords: poker,games,cards,texas holdem

## General Info
Command Line Single-player game of Texas Hold'Em poker. 

At the beginning of the game, you are asked to define how much cash each player will receive along with how many players you would like to play against. You can select from 1 to 4 players. Your competition is then randomly created and a player order is defined for the duration of the game. This order is used to control the blind and betting process.

The game consists of the following stages:
- Preflop: two pocket cards are dealt to each player and big/small blinds are processed
- Flop: discard top card from the stack and deal three community cards
- Turn: discard top card from the stack and deal one community card
- River: discard top card from the stack and deal last community card
- Showdown: player best hands are evaluated and winner is selected

After each of the above stages a round of betting takes place following the defined player order allowing players to check, call, raise or fold. If a player folds, they are simply removed from the player order and the game will continue with the remaining players. During the final stage of the game, the best hand for each player is selected, compared against other players and a winner is selected. 

Currently, logic for the following hands is supported:

- Three of a Kind
- Two Pair
- Pair
- High Card

Additionally, the game only supports use of white chips. I created issues for the remaining poker hands and chip denominations and plan to add them at a later date. While I have written and conducted a lot of testing to ensure a high quality experience, it's possible bugs do exist. Please report any you might experience and I will do my best to squash them promptly.

## Setup
```
$ pip install play-poker
$ python -m poker
```
DeepMuon 1.23.51
Interdisciplinary Deep Learning Platform
Requires Python: >=3.6, <4
Keywords: Deep Learning,Searching Dark Matter,Direct and Simple

<h1><center><img src="./Resources/DeepMuon.png" width='900px'></center></h1>

## Introduction

DeepMuon is a easy-using deep learning platform initially built for dark matter searching experiments. Up to now it has been a interdisciplinary deep learning platform. We are eager to provide advanced model training framework and excellent project management assistance.

Here we list out some available features of DeepMuon:

- **Single GPU** training， **Distributed Data Parallel** training and **Fully Sharded Distributed Parallel** training.
- Neural Network Hyperparameter Searching (NNHS)
- Gradient accumulation
- Gradient clipping
- Mixed precision training
- Double precision training
- Customize models
- Customize datasets
- Customize loss functions
- Tidy logging system
- Model interpretation
- Simple and direct tutorials

More details please refer to the home page of [DeepMuon](https://airscker.github.io/DeepMuon/).

## Installation (From source recommended)

```bash
git clone https://github.com/Airscker/DeepMuon.git
cd DeepMuon
pip install -v -e ./ --user
```

## CopyRight

> GNU AFFERO GENERAL PUBLIC LICENSE
>
> Project: DeepMuon
>
> Interdisciplinary Deep Learning Platform
>
> Author: Airscker/Yufeng Wang
>
> Contributors: Yufeng Wang, Shendong Su
>
> University of Science of Technology of China
>
> If you want to publish thesis using DeepMuon, please add bibliography:
>
> ```tex
> @misc{deepmuon,
>   author       = {Yufeng Wang},
>   title        = {DeepMuon: Interdisciplinary deep-learning platform},
>   year         = {2022},
>   publisher    = {GitHub},
>   journal      = {GitHub repository},
>   howpublished = {\url{https://airscker.github.io/DeepMuon}},
> }
> ```
> Copyright (C) 2023 by Airscker(Yufeng), All Rights Reserved.