semvec/pypi-packages huggingface dataset:
PIX-engine 0.2.0rc2
Terminal game engine that is community supported and open source
License: MIT
Requires Python: >=3.7.0


# PIX

[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/TVRework/PIX?quickstart=1)

PIX is a **python terminal game engine** that is community supported and open source. Develop **games 🎮** _(and applications)_ with **ease.**

## Installation

We offer two different versions. **Production Release** is the currently supported version while **Canary** is all RCs, alphas, and betas.

### Release

```shell
pip install PIX-engine
```

### Canary

Warning! This version may be unstable, not working as intented, and more. Please leave any feedback you have on our issues board.

```shell
pip install PIX-engine==0.2.0rc1
```

**Or,** clone this repoisitory to edit and contribute towards PIX's development and open source.
cvss-rescore 0.0.5
Rescore cvss3 and 3.1 results from any json file based on custom rules that you create.
License: MIT

.. image:: https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold
    :alt: Project generated with PyScaffold
    :target: https://pyscaffold.org/1

.. image:: https://bestpractices.coreinfrastructure.org/projects/6968/badge
    :alt: OpenSSF Badges
    :target: https://bestpractices.coreinfrastructure.org/projects/6968

============
cvss_rescore
============


    Rescore cvss3 and 3.1 results from any json file based on custom rules.

------------
The Problem
------------
Cvss scoring consists of three components: Base, Temporal, and Environmental.

When working with third-party dependency (SCA) vulnerabilities, 
nearly every tool reports it's scores only using the base score. This is
understandable, as the reporters of the vulnerabilities would only know about
the vulnerabilities themselves. They would have no idea how the vulnerable package
is actually used in your project. Do you have mitigating controls in place? Is it only
a test project? Is it only in a protected CI/CD pipeline? All of these factors and more
can impact the environmental score, which can lower the actual score of a vulnerability
significantly.

How We Use This
----------------

Output-Agnostic
================

We use the cvss-rescore packate as a post-processor after our SCA scan has been run. Because
the cvss-rescore package can take any json format output, it is tool-agnostic. We have tested 
it successfully using Dependabot and JFrog Xray, but there's no reason
any other tool can't be used so long as the output is json.

Rules-Based
============
Because we leverage the Python rule-engine package as a dependency, users can create a 
rules_actions.json file in their root directory. Users can create as many rules as they need, 
modifying one or more cvss vector metrics per rule. 

Requirements
=============
- Python 3.6 or higher
- A working knowledge of CVSS calcuation. You can reference the calculator at

| https://www.first.org/cvss/calculator/3.1     
| https://www.first.org/cvss/user-guide   
| https://www.first.org/cvss/v3.1/examples   

Installation
============

You can find the package at pypi.org
https://pypi.org/project/cvss-rescore/

To install, simply run 'pip install cvss-rescore' from the command line

Documentation
==============
You can get the current documentation at https://cvss-rescore.readthedocs.io/en/latest/

.. _pyscaffold-notes:

Dependencies
=============
| rule-engine: https://pypi.org/project/rule-engine/
| cvss: https://pypi.org/project/cvss/


Note
====

This project has been set up using PyScaffold 4.3.1. For details and usage
information on PyScaffold see https://pyscaffold.org/.
botodto 0.0.2
Pydantic interface codegen from Amazon Smithy JSON schemas
License: MIT
Requires Python: >=3.9

# botodto

Pydantic model codegen from AWS OpenAPI schemas generated from the AWS JS/TS SDK (v3)

## Mission statement

The goal of this library is to wrap `boto3` clients so that all calls to AWS APIs through them
are ingested into, and emit responses as Pydantic models.

## Implementation

OpenAPI schemas are produced from the AWS Javascript SDK (v2)
[in the OpenAPI Directory](https://github.com/APIs-guru/openapi-directory/tree/master/APIs/amazonaws.com)
by [the `aws2openapi` tool](https://github.com/APIs-guru/aws2openapi).

These can be used to produce reliable Pydantic data models using [`datamodel-code-generator`][dcg]
(_to clarify_: with minimal? no? manual editing of the result).

[dcg]: datamodel-code-generator "https://github.com/koxudaxi/datamodel-code-generator"

My implementation will take one of the following routes [_TBD_]:

- [ ] replaces the `aws2openapi` tool with a Python converter for the v3 SDK (simplest approach, more work?)
  - Theoretically this is the nicest approach
  - It isn't a good idea to approach this without a proof of concept that the proposed solution is viable

- [ ] amends the OpenAPI schema generated by `aws2openapi` from the v2 SDK to include exceptions from the v3 SDK
  - This could be a neat solution

- [ ] amends the Pydantic models to include exceptions from the v3 SDK (potentially awkward manual mapping exercise, but least work?)
  - This could be a simple proof of concept

I propose to start with the latter approach, for a single service, end to end, and stub out the other services.
After this is shown to work, automate the process for the other services.

## Reliability

- I will use a test suite to check the results work for all schemas (there are a lot!)

- I would like to avoid manual data transfer or generation where possible to make this repeatable,
  and not deteriorate after writing.
PoolFlow 0.0.6
A simple process management library
License: MIT

# PoolFlow



**A simple process management library**



## Introduction

**PoolFlow** provides simple objects to manage the execution of a variety of tasks and 
its memory usage. The main objective of **PoolFlow** is to perform a lot of scientific calculations
 and manage their successive executions through the subprocess library.

## Schematic principle

The way **PoolFlow** works could be synthesized by the following diagram. A list of jobs is 
given and the `pool` object manage the available virtual memory, considering the maximum estimated
cost of the job given by the user.



``` mermaid
graph LR
A[Job with<br>given cost]-->|Set of parameters|B{Pool};
B-->C[Estimated usage<br>memory];
C-->|Not enough<br>memory|B;
C-->|Memory available<br>and allocated|D[Job is<br>launched];
D-->|Job is done<br>memory est released|B;

```


## Installing 
The only external package **SourceFlow** depends on is `rich`. Install it directly via `pip`:


`pip install PoolFlow`



## [Documentation](https://victorgarric.github.io/PoolFlow/)


## Warning and known issues

**PoolFlow** uses management resources via `resource` native package. Due to the way `resource` work, some limitation
and unlimitation procedures are only available on Unix.