semvec/pypi-packages huggingface dataset:
zenity-py 1.0.7
A Python library for the CLI tool zenity.
License: MIT
Keywords: zenity

# zenity-py - Zenity for Python
Exactly what it says it is.

# How to install
Just type ```python3 -m pip install zenity-py``` and it should install just fine.

BUT, you need to also check if Zenity is installed.
Type in the Command Prompt/Terminal: ```zenity```.
If this is the output you get:
```
You must specify a dialog type. See 'zenity --help' for details
```
then you're good to go and you can get to using zenity-py.

If it says something like ```zsh: command not found: zenity``` or ```'zenity' is not recognized as an internal or external command, operable program or batch file.```, then you don't have it installed.

## How to install Zenity - Linux/Mac
On Linux, use your system's package manager or Homebrew to install it.
Example: ```sudo apt install zenity```

On Mac, use Homebrew to install it.
Example: ```brew install zenity```

## How to install Zenity - Windows
Install MinGW then search for Zenity in it. I don't use Windows anymore and I never really used MinGW for any other stuff other then make, so that's all i'm saying.

# How to use
In a python file, type
```python
from zenity import Zenity

# Zenity syntax - title, body, type, options[]
# the ! in !timeout means it is an option, not a value
z = Zenity("Title", "Body", "info", ["!timeout", 5])
```

This should create a new Zenity instance. Of course, this is an example, so you can change anything.
After that, add
```python
z.Open()
```

This should start up Zenity with the parameters you specified.
If a zenity window doesn't appear, something went wrong.
You can always print() the z variable, as the Zenity class returns both the status code and output.

If you want to know what arguments you can use, go over to the [Zenity Manual](https://help.gnome.org/users/zenity/stable/).
Do not add an option like !calendar or !password onto the options. Just change the type to "calendar" or "password".
ruffrgimportfixer 0.11
Fixes missing imports using Ruff and RipGrep (CLI and import)
License: MIT
Keywords: import,ripgrep,ruff


# Fixes missing imports using Ruff and RipGrep (CLI and import)

## Tested against Windows / Python 3.11 / Anaconda

## pip install ruffrgimportfixer

A Python script for adding missing import statements in your Python code.
The script utilizes ruff and ripgrep to identify missing imports and organizes them based on various criteria, including the number of errors, the total number of imports, and the length of the import line.

```python
Usage:
    from ruffrgimportfixer import fix_imports
	fix_imports('some_pythonfile.py')
	# or from the commandline ('some_pythonfile.py' as the only arg)

    # or a simple bat file: 
    python -c "from ruffrgimportfixer import fix_imports;fix_imports(r'''%*''')"

    
Dependencies:
    - ruff (https://github.com/astral-sh/ruff)
    - ripgrep (https://github.com/BurntSushi/ripgrep)
	# Both must be in sys.path
```
prototypal 0.1.1
Javascript-like prototypes for Python.
License: MIT
Requires Python: >=3.11

# prototypal

This is an experimental module I created to see if I could get Javascript-like prototypes implemented in Python 3. It's
not Pythonic but it works. Feel free to PR if you want to contribute to it.

## Usage

```python
from prototypal.prototype import *


# create a new type using @constructor
@constructor
def Person(this, first, last):
    this.firstName = first
    this.lastName = last


# initialize an instance
bird = Person('Charlie', 'Parker')
print(bird.firstName)  # Output: 'Charlie'
print(bird.lastName)  # Output: 'Parker'

# dynamically add attributes
bird.instrument = 'alto sax'
print(bird.instrument)  # Output: 'alto sax'

# unset attributes just return None
print(bird.age)  # Output: None


# add methods to the instance
def sing(this):
    print('%s sings!!' % this.lastName)


bird.sing = sing.__get__(bird)
bird.sing()  # Output: 'Parker sings!!'


# use the prototype chain to add properties and methods to the type
def getName(this):
    return '%s %s' % (this.firstName, this.lastName)


Person.prototype.name = property(getName)

print(bird.name)  # Output: 'Charlie Parker'


def greet(this):
    print('Hello, my name is %s' % this.name)


Person.prototype.greet = greet.__get__(bird)
bird.greet()  # Output: 'Hello, my name is Charlie Parker'

monk = Person('Thelonious', 'Monk')
monk.greet = greet.__get__(monk)
monk.greet()  # Output: 'Hello, my name is Thelonious Monk'


# property setter
def setName(this, name):
    first, last = name.split(' ')
    this.firstName = first
    this.lastName = last


Person.prototype.name = property(getName, setName)

bird.name = 'Dizzy Gillespie'
print(bird.firstName)  # Output: 'Dizzy'
print(bird.lastName)  # Output: 'Gillespie'


# property deleter
def deleteName(this):
    print('Deleting %s.' % this.name)
    del this.firstName
    del this.lastName


Person.prototype.name = property(getName, setName, deleteName)
del bird.name  # Output: 'Deleting Dizzy Gillespie.'
print(bird.name)  # Output: 'None None'

# using prototype inheritance
father = Person('Tom', 'Bard')
son = Person('Tommy', 'Bard')
son.__proto__ = father
father.eyeColor = 'blue'
print(son.eyeColor)  # Output: 'blue'

# prototype chain relationships
assert son.__proto__ == father
assert son.constructor == father.constructor == Person
assert father.__proto__ == Person.prototype
assert Object.prototype.constructor == Object
assert Person.prototype.constructor == Person
assert Person.prototype.__proto__ == Object.prototype

# should work with lists
father.children = [son]
print(len(father.children))  # Output: 1

########################################################

# Usage of the new features
# Creating a prototype with attributes
jane = create_prototype(first='Jane', last='Doe')

# Chaining prototypes
parent_proto = create_prototype(eye_color='blue')
child_proto = chain_prototypes(parent_proto)

# Cloning a prototype
clone_jane = clone_prototype(jane)

# Dynamic attribute setting
jane.middle = 'Ann'

# Representation customization
print(jane)  # Output: <Proto object at 0x...>
```
opqua 1.2.1
An epidemiological modeling framework for population genetics and evolution.
License: MIT
Requires Python: >=3.9
Keywords: epidemiology,evolution,biology

Opqua is an epidemiological modeling framework for population genetics and evolution. Opqua stochastically simulates  pathogens with specific, evolving genotypes spread through  populations of hosts that can have specific immune profiles. 

Opqua is a useful tool to test out scenarios, explore hypotheses, and make predictions about the relationship between pathogen evolution and epidemiology. 

 Visit github.com/pablocarderam/opqua for more information.