semvec/pypi-packages huggingface dataset:
studiopulsee 0.17.1
It's a Python library for VFX project-based LAN deployment



studiopulsee, the studiopulsee API is the memory of your animation production 
-------------------------------------------------------------

The studiopulsee API allows to store and manage the data of your animation/VFX
production. Through it, you can link all the tools of your pipeline and make
sure they are all synchronized.

A dedicated Python client, _, allows users to
integrate studiopulsee into the tools. 

|CI badge| |Downloads badge| |Discord badge|

Features
~~~~~~~~

studiopulsee can:

-  Store production data, such as projects, shots, assets, tasks, and file metadata.
-  Track the progress of your artists
-  Store preview files and version them
-  Provide folder and file paths for any task
-  Import and Export data to CSV files
-  Publish an event stream of changes

Installation and Documentation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Installation of studiopulsee requires the setup of third-party tools such as a database
instance, so it is recommended to follow the documentation:




Contributing
------------

Contributions are welcomed so long as the 


studiopulsee is based on Python and the `Flask <http://flask.pocoo.org/>`__
framework.

You can use the pre-commit hook for Black (a Python code formatter) before
committing:

.. code:: bash

    pip install pre-commit
    pre-commit install





Contributors
------------

* @Hi Tech Interprise()
* @Divyesh Gohil (studiopulsee) - *maintainer*

About authors
~~~~~~~~~~~~~

studiopulsee is , a company based in Mumbai. We help with animation and
VFX studios to collaborate better through efficient tooling. We already work
with more than 10 studios around the Maharashtra.
spi-solidity-predicate-inspector 0.1.1
SPi (Solidity Predicate Inspector): Solidity Semantic Predicate Comparison Tool
Requires Python: >=3.8

# SPi: Solidity Semantic Predicate Comparison Tool

SPi [spaɪ], the Solidity Predicate Inspector, is a tool for comparing two boolean predicates written in Solidity, a smart contract programming language. SPi determines if two predicates are equivalent or if one is stronger than the other.

## Features

- Tokenizes and parses Solidity predicates into an Abstract Syntax Tree (AST)
- Simplify AST using symbolic mathematics
- Compare predicates for equivalence and logical strength

## Getting Started

### Prerequisites

- Python 3.8 or higher
- Install required packages using pip

```sh
pip install -r requirements.txt
```

### Running the Tests

To ensure everything is set up correctly, run the unit tests:

```sh
python -m unittest discover -s tests
```

### Usage

You can compare two predicates using the `main.py` script. Here's an example:

```sh
python main.py "msg.sender == msg.origin" "a < b"
```

This will output whether the predicates are equivalent, or which one is stronger.

## Example

```sh
$ python main.py "msg.sender == msg.origin" "msg.origin == msg.sender"
The predicates are equivalent.

$ python main.py "msg.sender == msg.origin && a >= b" "msg.sender == msg.origin"
The first predicate is stronger.

$ python main.py "msg.sender == msg.origin || a < b" "a < b"
The second predicate is stronger.
```
SPi-Solidity-Predicate-Inspector 0.1.0
SPi (Solidity Predicate Inspector): Solidity Semantic Predicate Comparison Tool
Requires Python: >=3.8

# SPi: Solidity Semantic Predicate Comparison Tool

SPi [spaɪ], the Solidity Predicate Inspector, is a tool for comparing two boolean predicates written in Solidity, a smart contract programming language. SPi determines if two predicates are equivalent or if one is stronger than the other.

## Features

- Tokenizes and parses Solidity predicates into an Abstract Syntax Tree (AST)
- Simplify AST using symbolic mathematics
- Compare predicates for equivalence and logical strength

## Getting Started

### Prerequisites

- Python 3.8 or higher
- Install required packages using pip

```sh
pip install -r requirements.txt
```

### Running the Tests

To ensure everything is set up correctly, run the unit tests:

```sh
python -m unittest discover -s tests
```

### Usage

You can compare two predicates using the `main.py` script. Here's an example:

```sh
python main.py "msg.sender == msg.origin" "a < b"
```

This will output whether the predicates are equivalent, or which one is stronger.

## Example

```sh
$ python main.py "msg.sender == msg.origin" "msg.origin == msg.sender"
The predicates are equivalent.

$ python main.py "msg.sender == msg.origin && a >= b" "msg.sender == msg.origin"
The first predicate is stronger.

$ python main.py "msg.sender == msg.origin || a < b" "a < b"
The second predicate is stronger.
```
attribox 0.1.33
Allows for deferred instantiation of class attributes.
Requires Python: >=3.9

# AttriBox - Python Descriptors the Easy Way

## Installation

Install `AttriBox` easily with pip:

```bash
pip install attribox
```

## Quick Start

Imagine having nested custom classes with a requirement of descriptor
protocol implementation. The AI advices you to rethink the design, before
they present you with hundreds of lines of syntactic broccoli. Meanwhile,
your friends are asking you what you are doing with your life. Well, the
AttriBox is here to help!

```python
class SomeGraphics:
  """Imagine you wish to encapsulate a graphical problem in a class. You 
  already have custom classes for the components, but now you wish you 
  had implemented them as descriptors, but of course descriptors are 
  unique to the class and not to the instance. The memories are coming. 
  With them tears begin to form. Never fear! AttriBox is here!"""

  fillColor = AttriBox[RGB](144, 255, 0)
  borderColor = AttriBox[RGB](0, 0, 0)
  centeredDiv = AttriBox[GetRect](69, 420)
```

The above code implements the class attributes as descriptors. The
`AttriBox` holds on to the class for you, until one of your instances
invokes `__get__` at which point `AttriBox` creates a dedicated specimen for
just your instance.

# A More Ambitious Example

Suppose you are designing a graphical user interface. You wish to use
the descriptor protocol to expose the I/O communication directly to the
user interface. You see all of those wonderful numbers over there on the
robot or whatever, and you see those tempting '__set__' methods on your
descriptors.

```python

class MainApp(QMainWindow):
  """The basic application window."""

  mainMenuBar = AttriBox[MenuBar](this)  # yes, 'this' is a thing
  mainStatusBar = AttriBox[StatusBar](this)  # fr

  baseLayout = AttriBox[Grid]()
  baseWidget = AttriBox[QWidget]()
  indicator = AttriBox[Indicator]()
  button = AttriBox[Button]()
  slider = AttriBox[Slider]()

  def initUi(self) -> None:
    """Initializes the user interface."""
    self.baseLayout.addWidget(self.indicator, 0, 0)
    self.baseLayout.addWidget(self.button, 1, 0)
    self.baseLayout.addWidget(self.slider, 2, 0)
    self.baseWidget.setLayout(self.baseLayout)
    self.setCentralWidget(self.baseWidget)
    self.setMenuBar(self.mainMenuBar)
    self.setStatusBar(self.mainStatusBar)

  def connectSignals(self) -> None:
    """Connects the signals to the slots."""
    self.button.clicked.connect(self.indicator.toggle)
    self.slider.valueChanged.connect(self.indicator.setValue)
    self.slider.valueChanged.connect(self.mainStatusBar.setValue)

```
pytest-jira-xfail 1.2.1
Plugin skips (xfail) tests if unresolved Jira issue(s) linked
Requires Python: >=3.9

# pytest-jira-xfail

Plugin skips (xfail) tests linked to unresolved Jira issue(s)

## 1. Generate your Jira API token

You should have Jira user
with [API token generated](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/)

## 2. Add PytestJiraHelper to your pytest hook:

```python
import pytest

from pytest_jira_xfail.jira_helper import PytestJiraHelper


@pytest.hookimpl(tryfirst=True)
def pytest_collection_modifyitems(items):
    jira = PytestJiraHelper(
        jira_url="https://company.atlassian.net",
        jira_username="my_jira_user@company.com",
        jira_api_token="my_jira_user_api_token",
    )
    jira.process_linked_jira_issues(items)
```

## 3. Link bugs to your tests

```python
from pytest_jira_xfail.annotations import bug


@bug("MP-123")
def test_my_test_fails():
    assert False


@bug("MP-124", IndexError)
def test_my_test_broken():
    db_records = []
    assert db_records[0]


@bug("MP-124")
@bug("MP-124", IndexError)
def test_multiple_exceptions():
    db_records = []
    assert db_records[0][0] == 'active'
```

XFAIL message format:

```
XFAIL The test is skipped because of open bugs:
https://company.atlassian.net/browse/MP-123
```

## 4. [Optional] Set custom resolved statuses

By default, only issues with the status "Done" and "Closed" are considered as resolved.<br>
But you can override this and add more statuses, as following:

```python
import pytest

from pytest_jira_xfail.jira_helper import PytestJiraHelper


@pytest.hookimpl(tryfirst=True)
def pytest_collection_modifyitems(items):
    jira = PytestJiraHelper(
        jira_url="https://company.atlassian.net",
        jira_username="my_jira_user@company.com",
        jira_api_token="my_jira_user_api_token",
        resolved_statuses=["Done", "Closed", "Released", "Declined"]
    )
    jira.process_linked_jira_issues(items)
```
envtyped 0.1.1
Strong typing for your environment variables
Requires Python: <4.0,>=3.10

# 🦕 envtyped

This library is heavily inspired by [python-decouple](https://github.com/HBNetwork/python-decouple). Main goal is to provide a simple way to load environment variables, with type hinting, for my FastAPI projects.

## 📝 Table of Contents

- [📝 Table of Contents](#-table-of-contents)
- [📦 Installation](#-installation)
- [🚀 Usage](#-usage)
- [📝 License](#-license)

## 📦 Installation

```bash
pip install envtyped
```

## 🚀 Usage

```python
from envtyped import config

# Get environment variable, no need to do anything else, .env file is lazy loaded
SECRET_KEY = config.get("MY_ENV_VAR") # str

# You can cast the value to another type
DELAY_IN_SECONDS = config.get("DELAY_IN_SECONDS", cast=int) # int

# You can also use a custom function to cast the value
DELAY = config.get("DELAY", cast=lambda x: datetime.fromtimestamp(int(x))) # datetime

# If you need to, you also can use a custom class to cast the value, that can be constructed from a string
class Employee:
    def __init__(self, name: str) -> None:
        self.name = name.capitalize()

    def hello(self) -> str:
        return f"Hello {self.name}"


EMPLOYEE = config.get("EMPLOYEE", cast=Employee) # Employee
EMPLOYEE.hello()
# -> Hello John

# By default all env variables are required, but you can also set a default value
SECRET_KEY = config.get("SECRET_KEY", default="default_secret_key")

# Or you can set a value to be optional
SECRET_KEY = config.get("SECRET_KEY", optional=True) # Optional[str]


# This library provides a helpers to read csv 
from envtyped import Csv

AVAILABLE_LANGUAGES = config.get("AVAILABLE_LANGUAGES", cast=Csv()) # List[str]

# Csv can also be used to cast a list of string to a list of class
class Language:
    def __init__(self, name: str) -> None:
        self.name = name

AVAILABLE_LANGUAGES = config.get("AVAILABLE_LANGUAGES", cast=Csv(cast=Language)) # List[Language]

# Choise is a helper to limit the value to a list of choice
from envtyped import Choise

USER_LANGUAGE = config.get("USER_LANGUAGE", cast=Choise(["en", "fr"])) # str
USER_CURRENCY = config.get("USER_CURRENCY", cast=Choise(["usd", "eur"], default="usd")) # str


```

## 📝 License

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

With ❤️