semvec/pypi-packages huggingface dataset:
model-perf 0.0.1rc1
Model Performance Toolkit (model-perf) is a Python package backed by test applications for different platforms (Windows/MacOS, Android/iOS, Web) to test machine learning models on different target platforms and devices (e.g., Google Pixel for Android, iPhone for iOS).
Requires Python: >=3.7

# Model Performance Toolkit
Model Performance Toolkit (model-perf) is a Python package backed by test applications for different platforms (Windows/MacOS, Android/iOS, Web) to test machine learning models on different target platforms and devices (e.g., Google Pixel for Android, iPhone for iOS).
cis 1.7.8
Community Intercomparison Suite

CIS
===

[![Join the chat at https://gitter.im/cedadev/cis](https://badges.gitter.im/cedadev/cis.svg)](https://gitter.im/cedadev/cis?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Build Status](https://circleci.com/gh/cedadev/cis/tree/master.svg?style=svg)](https://circleci.com/gh/cedadev/cis/tree/master)
[![codecov](https://codecov.io/gh/cedadev/cis/branch/master/graph/badge.svg?token=8QTY6ZZN95)](https://codecov.io/gh/cedadev/cis)
[![Documentation Status](https://readthedocs.org/projects/cis/badge/?version=latest)](https://readthedocs.org/projects/cis/?badge=latest)
[![Downloads](https://anaconda.org/conda-forge/cis/badges/downloads.svg)](https://anaconda.org/conda-forge/cis/files)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4518867.svg)](https://doi.org/10.5281/zenodo.4518867)


CIS is an open source Python library and command-line tool for the easy collocation, visualization, analysis, and comparison of a
diverse set of gridded and ungridded datasets used across earth sciences. Visit our homepage at www.cistools.net.

For issue tracking and improvement suggestions please see our JIRA project at: https://jira.ceh.ac.uk/projects/JASCIS/issues.

Installation
------------

A pre-packaged version of CIS is available for installation using conda for Linux, Mac OSX and Windows.

Once conda is installed, you can easily install CIS with the following command:

    conda install -c conda-forge cis

If you don’t already have conda, you must first download and install it.
Anaconda is a free conda package that includes Python and many common scientific and data analysis libraries, and is available here: http://continuum.io/downloads.
Further documentation on using Anaconda and the features it provides can be found here: http://docs.continuum.io/anaconda/index.html

More details for installing CIS from source, and other package sources, can be found in the get-started [documentation](http://cistools.net/get-started#installation).


Contact
-------

Philip.Kershaw@stfc.ac.uk, Philip.Stier@physics.ox.ac.uk or Duncan.Watson-Parris@physics.ox.ac.uk


Copyright and licence
---------------------

(C) University of Oxford 2013

This file is part of the Community Intercomparison Suite (CIS).

CIS is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

CIS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with CIS.  If not, see <http://www.gnu.org/licenses/>.

We gratefully use a number of NASA Visible Earth 'Blue Marble' raster 
images in this repository.
dpyuserembed 0.0.5
A package to allow discord users to use embeds again

# dpyselfembed
A way for selfbots to send embeds again.  
It uses [Rauf's embed generator](https://embed.rauf.wtf/).

### Install
> ```bash
> $ pip install dpyselfembed
> ```

### Example
> ```python
> import dpyselfembed
> 
> embed = dpyselfembed.Embed("dpyselfembed", 
>   description="A way for selfbots to send embeds again.", 
>   colour="ff0000"
> )
> embed.set_author("Benny")
> 
> url = embed.generate_url(hide_url=True) # You can also convert the embed to a string.
> print(url) # The url will be put in your ctx.send() content.
> ```

### Limitations
> Because the embeds are web embeds there are limitations.  
> - No footers.
> - Max 350 character description.

### Credits
> Used code from [Discord.py Self Embed](https://github.com/bentettmar/discord.py-self_embed)
dagline 0.1.0
Use Python's multiprocessing module to execute tasks(python functon and windows bat script) of a DAG in parallel
Requires Python: >=3.10

## Overview

Dagline is a package for executing multiple tasks of a DAG flow in parallel. The type of task can be python function and Windows bat script.

### System Requirements

*   Python 3.10+

### Installation

*   python -m pip install dagline

### Use-cases

*   **Create a folder where you put the dag files locally. You can name your folder/py whatever you want:**  
    dags\\  
            └──dag\_example.py  
     
*   **Define the DAG, open** _**dag\_example.py**_ **and enter the following content:**

```python

from dagline.models.dag import DAG
from dagline.models.operators.winbat import WinbatOperator
from dagline.models.operators.python import PythonOperator


def read_excel():
    '''Do your works here'''
    print('call this func read_excel')
    
def read_csv():
    '''Do your works here'''
    print('call this func read_csv')
    
def load_to_db():
    '''Do your works here'''
    print('call this func load_to_db')


task1 = PythonOperator(task_id = 'read_excel', python_callable = read_excel)
task2 = PythonOperator(task_id = 'read_csv', python_callable = read_csv)
task3 = PythonOperator(task_id = 'load_to_db', python_callable = load_to_db)
task4 = WinbatOperator(task_id = 'housekeep', bat_command = r"C:\xxx\housekeep.bat")


'''DAG graph, child task : [parent tasks]'''
tasks_flow ={
task1 : [],
task2 : [],
task3 : [task1, task2],
task4 : [task3]
}


with DAG(
    dag_id = 'dag_example',
    tasks_flow = tasks_flow,
    logfile = "C:\xxx\dag_example.log",
    retry_cnt = 3,
    retry_delay = 10 #seconds
) as dag:
    pass


```

*   **Run a DAG in parallel or run a DAG from some specified tasks**

_python -m dagline dags run \<dag\_files\_home> \<dag\_id> \< --start\_with\_task\_ids >_  
         dag\_files\_home                     The folder of the DAG files  
         dag\_id                                    The id of the dag  
         --start\_with\_task\_ids            A list of the task ids, if it was provided, the DAG will start from these tasks, not from the beginning of the DAG

```python
>python -m dagline dags run C:\xxx\dags_tasks\dags dag_example1
>python -m dagline dags run C:\xxx\dags_tasks\dags dag_example1 --start_with_task_ids read_csv
```

*   **Run a task of the DAG**

_python -m dagline tasks run \<dag\_files\_home> \<dag\_id> \<task\_id>_  
        dag\_files\_home                     The folder of the DAG files  
        dag\_id                                    The id of the dag  
        task\_id                                   The id of the task, only runs this task in the DAG

```python
>python -m dagline tasks run C:\xxx\dags_tasks\dags dag_example read_csv
```

*   **Visualize  a DAG on the html page**

_python -m dagline dags show \<dag\_files\_home> \<dag\_id>_  
        dag\_files\_home                     The folder of the DAG files  
        dag\_id                                    The id of the dag

```python
>python -m dagline dags show C:\xxx\dags_tasks\dags dag_example
```
passfortify 0.0.2
A simple password strength checker package

# PassFortify

PassFortify is a Python package that evaluates the strength of passwords based on various criteria, such as length, complexity, and character types. It provides a simple and convenient way to assess the strength of passwords and enhance password security.

## Installation

You can install PassFortify using pip:

```shell
pip install passfortify
```

## Usage

```python
from passfortify import PasswordStrengthChecker

password = "my_password"
checker = PasswordStrengthChecker(password)
strength, score = checker.check_strength()

print(f"Password Strength: {strength}")
print(f"Password Score: {score}")
```

The `check_strength` method returns the strength classification and the score of the password. You can customize the scoring and classification thresholds according to your requirements.
automate-replit 0.1.4
Automate your replit account using this replit api wrapper!
Requires Python: >=3.10.0,<4.0.0
Keywords: replit,async,asyncio,aiohttp,api,api-wrapper

# Automate Replit
[![Documentation Status](https://readthedocs.org/projects/automate-replit/badge/?version=latest)](https://automate-replit.readthedocs.io/en/latest/?badge=latest)


Automate replit actions with this replit api wrapper!

## Docs
Documentation for this library can be found [here](https://automate-replit.readthedocs.io/en/docs/)

## Source
Source can be found [here](https://github.com/thatrandomperson5/automate-replit)

## Example
```py
from autoreplit import ReplitClient

client = ReplitClient()

async def getEthan():
    ethan = await client.getUserByName("not-ethan")
    print(f"Ethan's id: {ethan.id}")
    print(f"Ethan's follower count: {ethan.followerCount}")
    if ethan.isOnline:
        print("Ethan is online!")
    else:
        print(f"Ethan was last seen {ethan.lastSeen}")
    print(f"Ethan's roles: {ethan.roles}")
    print(f"All of ethan: {ethan}")

client.run(getEthan())
```
**Note**: pass a sid to get better info
opencv-stream 0.1.1
Wrapper over opencv for video processing and API development
Keywords: python,video,stream,AI,API


# opencv_stream

Under construction

Developed by Olivier 

## Examples of How To Use 

Creating A Stream


```python

from opencv_stream import VideoStreamer, ModelOutput, Model
import time
import numpy as np
import cv2

class TempModelOutput(ModelOutput):

    def to_dict(self) -> dict:
        return {"success": True}
    
    def draw(self, image: np.ndarray) -> None:
        w, h, _ = image.shape
        cv2.putText(image, "Hello from opencv_stream", (w//2, h//2), fontFace=1, fontScale=1, color=(255, 0, 0))

class TempModel(Model):

    def predict(self, image: np.ndarray) -> ModelOutput:
        return TempModelOutput()

stream = VideoStreamer.from_webcam()


stream.start_with_model(TempModel(), )


```