semvec/pypi-packages huggingface dataset:
noodleWrapper 0.0.1
A wrapper used for meme generating using Discord API
Requires Python: >=3.8, >=3.7

Noodles wrapper
===================
##### Created by Kabir Ghai (CypherGuy)

An extension module for [discord.py](https://pypi.org/project/discord.py/ "discord.py PyPi page") used as a meme-editor and welcome banners.

Notices:
-------

* This module was designed for [discord.py](https://pypi.org/project/discord.py/ "discord.py PyPi page") 1.7+ but may work with older versions, use at your own risk however.

Installation:
-------------

###### Install with pip:
```
pip install noodles-wrapper
```

###### Sample code with `lisastage`:
```
#Headers is optional.. for now.
text = noodles_wrapper.lisastage('test') #'test' is what you want it to say
print(text)
```

Links:
------

* [My website](https://frenchnoodles.xyz/api)
ischedule-aleksve 0.9
Open source, single-thread interval scheduler
Requires Python: >=3.8

An elegant and simple way to schedule periodic tasks in Python. Created because [`schedule`](https://github.com/dbader/schedule) is too complicated and counterintuitively does not account for the time it takes for the job function to execute. 

**Implementational details**

* Both the scheduler and the task run in the main thread. No new threads are created.
* Each task can run until it finishes.
* Each execution of `run_pending` checks the tasks in the same order as they were added by `schedule`. It executes the first task that is ready to be executed.* If a task was not executed during the scheduled interval, a single execution will be missed
* A task execution will be skipped if a the next execution of the same task is due by the time the control is returned to the scheduler.
* Exceptions during the execution are propagated out of `run_pending`, and can be dealth with by the caller.


**Example**

```python
import time

from src.ischedule.ischedule import schedule, run_loop
from threading import Event

start_time = time.time()
stop_event = Event()


def job_1():
    dt = time.time() - start_time
    print(f"Started a _fast_ job at t={dt:.2f}")
    if dt > 3:
        stop_event.set()


def job_2():
    dt = time.time() - start_time
    if dt > 2:
        return
    print(f"Started a *slow* job at t={dt:.2f}")
    time.sleep(1)


schedule(job_1, interval=0.1)
schedule(job_2, interval=0.5)

run_loop(stop_event=stop_event)
```
This example produces the following output:
```
Started a _fast_ job at t=0.10
Started a _fast_ job at t=0.20
Started a _fast_ job at t=0.31
Started a _fast_ job at t=0.41
Started a _fast_ job at t=0.50
Started a *slow* job at t=0.50
Started a _fast_ job at t=1.51
Started a *slow* job at t=1.51
Started a _fast_ job at t=2.52
Started a _fast_ job at t=2.61
Started a _fast_ job at t=2.71
Started a _fast_ job at t=2.81
Started a _fast_ job at t=2.90
Started a _fast_ job at t=3.00
```
The fast job runs every 0.1 seconds, and completes quickly. When the slow job starts running at t=0.5, it doesn't return control until one second later, at t=1.50s. By that time, both the fast and the slow job become pending, and are executed in the order they were added to the scheduler. The slow job does not run after t=2.0, so the fast job returns to running normally every 0.1 seconds.
aleksve 0.9
Open source, single-thread interval scheduler
Requires Python: >=3.8

An elegant and simple way to schedule periodic tasks in Python. Created because [`schedule`](https://github.com/dbader/schedule) is too complicated and counterintuitively does not account for the time it takes for the job function to execute. 

**Implementational details**

* Both the scheduler and the task run in the main thread. No new threads are created.
* Each task can run until it finishes.
* Each execution of `run_pending` checks the tasks in the same order as they were added by `schedule`. It executes the first task that is ready to be executed.* If a task was not executed during the scheduled interval, a single execution will be missed
* A task execution will be skipped if a the next execution of the same task is due by the time the control is returned to the scheduler.
* Exceptions during the execution are propagated out of `run_pending`, and can be dealth with by the caller.


**Example**
```python
import time

from src.ischedule import schedule, run_loop
from threading import Event

start_time = time.time()
stop_event = Event()

def job_1():
    dt = time.time() - start_time
    print(f"Started a _fast_ job at t={dt:.2f}")
    if dt > 3:
        stop_event.set()

def job_2():
    dt = time.time() - start_time
    if dt > 2:
        return
    print(f"Started a *slow* job at t={dt:.2f}")
    time.sleep(1)

schedule(job_1, interval=0.1)
schedule(job_2, interval=0.5)

run_loop(stop_event=stop_event)
```
This example produces the following output:
```
Started a _fast_ job at t=0.10
Started a _fast_ job at t=0.20
Started a _fast_ job at t=0.31
Started a _fast_ job at t=0.41
Started a _fast_ job at t=0.50
Started a *slow* job at t=0.50
Started a _fast_ job at t=1.51
Started a *slow* job at t=1.51
Started a _fast_ job at t=2.52
Started a _fast_ job at t=2.61
Started a _fast_ job at t=2.71
Started a _fast_ job at t=2.81
Started a _fast_ job at t=2.90
Started a _fast_ job at t=3.00
```
The fast job runs every 0.1 seconds, and completes quickly. When the slow job starts running at t=0.5, it doesn't return control until one second later, at t=1.50s. By that time, both the fast and the slow job become pending, and are executed in the order they were added to the scheduler. The slow job does not run after t=2.0, so the fast job returns to running normally every 0.1 seconds.
Convert-number-to-word 0.0.1
To convert positive integers into words as per international or Indian numbering system
Requires Python: >=3.6

This module help to convert postive integers into string as per International as well as Indian numbering system.

#BASIC INFORMATION:

*Max integer input is upto 20 digits
*As per Indian numbering system its highest position is Mahashank i.e(10**19)
*As per International numbering system its highest position is QUINTILLION i.e(10**19)
*1st arg is postive number,2nd arg is numbering system i.e international and Indian
*Default numbering system is International
*For educational purpose and office purpose.


#Example 1:
Given input number : x=123456
import num_to_word
z=num_to_word(x).word()
print(z)
#output : one hundred twenty three thousand four hundred fifty six

#Example 2:
Given input number : x=123456
import num_to_word
z=num_to_word(x,no_sys="INDIAN").word()
print(z)
#output : one lakh twenty three thousand four hundred fifty six

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~            Thanks alot for using it ;)          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
laptimize 1.0.1
package to solve separable non linear optimization problems
Keywords: python,nonlinear optimization,separable programming,branch and bound,global solution

laptimize - Linear Approximated Programming for Optimization
============================================================

laptimize is a python package to solve separable non convex optimization problems which is based on branch and bound algorithm developed by  James E.Falk (1972) of The
George Washington University. It has been proven that it can generate global solution for large class of nonlinear programming problems in a finite number of steps.
In many practical cases Nonlinear optimization problems are hard to solve and only limited methods are implemented. Many such problems, can be approximated arbitrarily closely by separable problems if all functions are piecewise linear. The laptimize python package will find a global optimum to these latter problems.

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

        pip install laptimize



## Dependencies

laptimize requires Python >= 3.6

NumPy (>= 1.19.2)

Pandas (>= 1.1.3)

PuLP (>= 2.3)




Examples
--------

Refer Examples directory for more examples

problem type which `laptimize` can applies

Separable linear/non-linear convex/non-convex minimization objective function

Minimize:


            F0(x1, x2) = 12x1 + 7x2 - x2^2


Subject to separable linear/non-linear convex/non-convex constraint with '<=' inequality

convex polygon

            F1(x1, X2) = 2x1 + x2 - 0 <= 0            
            
non convex constraint

            F2(x1, X2) = -2x1^4 -x2 +2 <= 0
            
            0 <= x1 <= 2, 0 <= x1 <= 3  
            
**Example Code**

    from laptimize.solver import Solver
    

    example_1 = {'objective': {'x1': lambda x: 12 * x, 'x2': lambda x: 7 * x - x ** 2},
                 'constraint_1': {'x1': lambda x: -2 * (x ** 4), 'x2': lambda x: -x, 'value': -2},
                 'constraint_2': {'x1': lambda x: 2 * x, 'x2': lambda x: x, 'value': 3},
                 'capacity': {'x1': [0, 2], 'x2': [0, 3]}}

        
    solution = Solver(example_1, partition_len=0.5).solve()
    
    
    print(solution)
        
**Comments, bug reports, patches and suggestions are welcome.**

* Comments and suggestions: https://github.com/uichathurika/laptimize/discussions
* Bug reports: https://github.com/uichathurika/laptimize/issues
* Patches: https://github.com/uichathurika/laptimize/pulls