semvec/pypi-packages huggingface dataset:
dudraw 1.10.1
A fork of Princeton's stddraw for use in classes at the University of Denver
Requires Python: >=3.8

# dudraw

## Description

Repository for `dudraw`, a fork of [stddraw from the Princeton Standard Libraries](https://introcs.cs.princeton.edu/python/code/).

## Installation

```
pip install dudraw
```

## Documentation

API Documentation: [https://cs.du.edu/~intropython/dudraw/](https://cs.du.edu/~intropython/dudraw/)

To build documentation:

```
pip install pydoctor
make docs
```

## License

Released under the [GNU Public License version 3 (GPLv3)](https://www.gnu.org/licenses/gpl-3.0.html)

## Authors

Original Authors of [StdLib](https://introcs.cs.princeton.edu/java/stdlib/):

    Robert Sedgewick
    Kevin Wayne
 
`dudraw` Fork Additions by:

    Joseph Brooksbank
    Ryan Dunagan
    Declan Kahn
    Eddy Rogers
    Andrew Hannum
    Mohammed Albow
    Jeff Edgington
nfkbin 1.0.0
NFkBin: Prediction of NF-Kbin
Requires Python: >=3.6

# **NF-kBIn**
A computational approach to predict the NF-kB inhibitors using the SMILES information of the molecules.
## Introduction
NF-kBIn is developed to predict the NF-kB inhibitors using the SMILES information of the molecules. In the standalone version, support vector classifier based model is implemented.
NF-kBIn is also available as web-server at https://webs.iiitd.edu.in/raghava/nfkbin. Please read/cite the content about the NF-kBIn for complete information including algorithm behind the approach.

## Standalone
The Standalone version of NF-kBIn is written in python3 and following libraries are necessary for the successful run:
- scikit-learn
- Pandas
- Numpy
- obabel (http://openbabel.org/docs/index.html)
- PaDEL-Descriptor (http://yapcwsoft.com/dd/padeldescriptor/PaDEL-Descriptor.zip)

## Minimum USAGE
To know about the available option for the stanadlone, type the following command:
```
python nfkbin.py -h
```
To run the example, type the following command:
```
python3 nfkbin.py -i example_input.txt
```
This will predict if the submitted molecules are NF-kB inhibitors or not. It will use other parameters by default. It will save the output in "outfile.csv" in CSV (comma seperated variables).

## Full Usage
```
usage: nfkbin.py [-h] 
                       [-i INPUT 
                       [-o OUTPUT]
		       [-t THRESHOLD]
		       [-d {1,2}]
```
```
Please provide following arguments for successful run

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input: Moleculues in the SMILES format per line
  -o OUTPUT, --output OUTPUT
                        Output: File for saving results by default outfile.csv
  -t THRESHOLD, --threshold THRESHOLD
                        Threshold: Value between 0 to 1 by default 0.41
  -d {1,2}, --display {1,2}
                        Display: 1:NF-kB inhibitors only, 2: All molecules, by default 1
```

**Input File:** It allow users to provide input in the SMILES format.

**Output File:** Program will save the results in the CSV format, in case user do not provide output file name, it will be stored in "outfile.csv".

**Threshold:** User should provide threshold between 0 and 1, by default its 0.16.

**Display type:** This option allow users to fetch either only NF-kB inhibitors by choosing option 1 or prediction against all molecules by choosing option 2.

NF-kBIn Package Files
=======================
It contantain following files, brief descript of these files given below

INSTALLATION                    : Installations instructions

LICENSE                         : License information

README.md                       : This file provide information about this package

model.zip                       : This zipped file contains the compressed version of model

nfkbin.py                       : Main python program

example_input.txt               : Example file contain molecules in SMILES format

example_output.csv              : Example output file
daba 1.0.2
daba by Klivolks.

# daba by Klivolks

The `daba` library, developed by Klivolks, is a Python package designed to simplify the process of interacting with databases. It provides convenient and easy-to-use methods for carrying out common database operations such as querying, inserting, updating, and deleting data. Primarily focused on Mongo is expected to grow to other Query languages.

## Installation

This package can be installed using pip:

```bash
pip install daba
```

## Environment Variables

Two environment variables need to be set:

- `MONGO_URL`: This is the URL of the MongoDB server.
- `MONGO_DB`: This is the name of the MongoDB database to interact with.

And optional variables are

- `MONGO_POOL_SIZE`: This is the default pool size of the MongoDB database.

These can be set in an `.env` file that can be loaded with `python-dotenv`. Remember not to commit sensitive data (like your database URLs) to version control!

## Example usage

In this example, the `collection` class from the `daba.Mongo` module is being used to interact with a MongoDB collection. 

You can create a collection object using the `collection` method:
```python
db_obj = collection('test')
```
The `collection` object has several methods to interact with the MongoDB collection.

### Methods

Below are the methods available in the `daba` library's `collection` class, along with brief descriptions of what they do:

- `init_db()`: Initializes the MongoDB database.
- `close_db()`: Closes the MongoDB database connection.
- `get(query)`: Returns documents that match the query.
- `find(query)`: Aggregate function.
- `put(data)`: Inserts a single document into the collection.
- `putMany(data)`: Inserts multiple documents into the collection.
- `set(query, new_data)`: Updates a single document that matches the query.
- `inc(query, data_to_increment)`: Increments the value of specific fields in a document that matches the query.
- `setMany(query, new_data)`: Updates multiple documents that match the query.
- `getOne(query)`: Returns a single document that matches the query.
- `getAfterCount(query, field)`: Returns a document after incrementing the value of a specific field.
- `deleteOne(query)`: Deletes a single document that matches the query.
- `deleteMany(query)`: Deletes multiple documents that match the query.
- `removeElement(query, element)`: Removes an element from an array in the documents that match the query.
- `count(query)`: Counts the documents that match the query.
- `createIndex(field, options)`: Creates index to the current table. Can use list of tuple of indexes or a single string.

## Running Tests

This library includes a suite of unit tests. To run the tests, execute the script with a Python interpreter. Ensure the `.env` file is in the same directory as the script.

```bash
python test_daba.py
```

## Note

This README is not exhaustive, and is intended to be a brief introduction to the functionality provided by the `daba` library. For a full list of functionality and options, please refer to the official documentation.
rpdb 0.2.0
pdb wrapper with remote access via tcp socket
Requires Python: >=3.8

# rpdb - remote debugger based on pdb

rpdb is a wrapper around pdb that re-routes stdin and stdout to a socket
handler. By default it opens the debugger on port 4444:

```python
import rpdb; rpdb.set_trace()
```

But you can change that by simply instantiating Rpdb manually:

```python
import rpdb
debugger = rpdb.Rpdb(port=12345)
debugger.set_trace()
```

It is known to work on Jython 2.5 to 2.7, Python 2.5 to 3.1. It was written
originally for Jython since this is pretty much the only way to debug it when
running it on Tomcat.

Upon reaching `set_trace()`, your script will "hang" and the only way to get it
to continue is to access rpdb using telnet, netcat, etc..:

```shell
nc 127.0.0.1 4444
```

## Installation in CPython (standard Python)

```shell
pip install rpdb
```

For a quick, ad hoc alternative, you can copy the entire rpdb subdirectory
(the directory directly containing the __init__.py file) to somewhere on your
`$PYTHONPATH`.

## Installation in a Tomcat webapp

Just copy the rpdb directory (the one with the __init__.py file) in your
WEB-INF/lib/Lib folder along with the standard Jython library (required).

## Trigger rpdb with signal

`set_trace()` can be triggered at any time by using the TRAP signal handler.
This allows you to debug a running process independently of a specific failure
or breakpoint:

```python
import rpdb
rpdb.handle_trap()

# As with set_trace, you can optionally specify addr and port
rpdb.handle_trap("0.0.0.0", 54321)
```

Calling `handle_trap` will overwrite the existing handler for SIGTRAP if one has
already been defined in your application.

## Known bugs

- The socket is not always closed properly so you will need to ^C in netcat
  and Esc+q in telnet to exit after a continue or quit.
- There is a bug in Jython 2.5/pdb that causes rpdb to stop on ghost
  breakpoints after you continue ('c'), this is fixed in 2.7b1.

## Author(s)

Bertrand Janin <b@janin.com> - http://tamentis.com/

With contributions from (chronological, latest first):

- Cameron Davidson-Pilon - @CamDavidsonPilon
- Pavel Fux - @fuxpavel
- Ken Manheimer - @kenmanheimer
- Steven Willis - @onlynone
- Jorge Niedbalski R <niedbalski@gmail.com>
- Cyprien Le Pannérer <clepannerer@edd.fr>
- k4ml <kamal.mustafa@gmail.com>
- Sean M. Collins <sean@coreitpro.com>
- Sean Myers <sean.myers@redhat.com>

This is inspired by:

- http://bugs.python.org/issue721464
- http://snippets.dzone.com/posts/show/7248
replaceapplemusic 0.0.2
A Python utility to replace source files of songs in Apple Music while preserving metadata
Requires Python: >=3.6

# ReplaceAppleMusic

A Python utility to replace source files of songs in Apple Music while preserving metadata like play count, favorite status, and playlist memberships.

## Features

- Preserves play count
- Maintains favorite status
- Keeps playlist memberships
- Automatically removes old track after replacement

## Requirements

- macOS
- Python 3.x
- Apple Music app

## Installation

You can install it directly from PyPI:
```bash
pip install replaceapplemusic
```

Or install from source:
1. Clone this repository
2. Install dependencies:
```bash
pip install -r requirements.txt
```
3. Make sure Apple Music is running and you have the necessary permissions

## Usage

```bash
# Replace a song
ramusic /path/to/new/file.m4a

# Replace songs in a folder
ramusic /path/to/folder
```
wikilite 0.1.0
A lightweight SQLite-based storage for Wikidict senses
Requires Python: >=3.7

# wikilite

A lightweight SQLite-based storage for wiktionary senses.

## Description

wikilite is a Python package that provides efficient SQLite-based storage for wiktionary senses. It is designed to store and manage dictionary sense data from wiktionary in a lightweight SQLite database, making it easy to integrate with Python projects that need to work with dictionary data.

## Installation

You can install wikilite using pip:

```bash
pip install wikilite
```

## License

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

## Links

- GitHub: https://github.com/ysenarath/wikilite