semvec/pypi-packages huggingface dataset:
PD-tkclock 1.1
PD_tkclock can use for simple timer, digital clock and stopwatch
License: MIT
Keywords: python,tkinter,clock,timer,stopwatch,pydoceo

#**_PD_tkclock_**

Pd_tkclock is simple and "programmable" clock used only in tkinter
project.
### How to install
Installation via pip
```commandline
pip install PD_tkclock
```

### Short Documentation

####***Digital Clock***
Code to make simple _**Digital Clock**_ in your tkinter window.
```python
import tkinter
from PD_tkclock import DigitalClock
root = tkinter.Tk()
label = tkinter.Label(root, font=("TkTextFont", 50))
label.pack()
DigitalClock(label)
root.mainloop()
```
####***Timer***
Code to make simple **_Timer_** in your tkinter window.
```python
import tkinter
from PD_tkclock import Timer
root = tkinter.Tk()
label = tkinter.Label(root, font=("TkTextFont", 50))
label.pack()
Timer(label, minute=10, second=10)
root.mainloop()
```
####***Stopwatch***
Code to make simple **_Timer_** in your tkinter window.
```python
import tkinter
from PD_tkclock import StopWatch
root = tkinter.Tk()
label = tkinter.Label(root, font=("TkTextFont", 50))
label.pack()
stopwatch = StopWatch(label)
stopwatch.start()
root.mainloop()
```

####License
MIT
git-config 1.0.0
Get local or global git config as a dictionary
License: MIT
Requires Python: >3

# git_config

> Get git config as a dictionary

## Installation

```sh
pip install git_config
```

## Usage

```py
from git_config import get_config

# Global git config
config = get_config()
config["user"]["name"] # Roshan Acharya
config["user"]["email"] # acharyaroshan2357@gmail.com

# Local git config
config = get_config("local")
config['remote "origin"']["url"] # git@github.com:coderosh/git_config.git
```
instance-builder 0.1.8
Instance builder library for Python inspired by Lombok
License: MIT
Requires Python: >=3.9,<4.0
Keywords: Instance Builder,Builder,Lombok

# Instance-Builder - Instance builder library for Python inspired by Lombok

![Python Versions](https://img.shields.io/pypi/pyversions/instance-builder.svg)
![PyPI version](https://badge.fury.io/py/instance-builder.svg)
![CI](https://github.com/shimech/instance-builder/actions/workflows/test.yml/badge.svg)

## Installation

```shell
pip install instance-builder
```

## Usage

Builder

```python
@builder("id", "name", "age", "email")
class User:
    def __init__(self, id: int, name: str, age: int, email: str) -> None:
        self.id = id
        self.name = name
        self.age = age
        self.email = email

user = User.Builder().id(0).name("Shuntaro Shimizu").age(99).email("ut.s.shimizu@gmail.com").build()
```

Getter

```python
@getter
class User:
    __id: int = 0
    __name: str = "Shuntaro Shimizu"

user = User()
user.get_id()  # 0
user.get_name()  # "Shuntaro Shimizu"
```

Setter

```python
@setter
class User:
    __id: int = 0
    __name: str = "Shuntaro Shimizu"

user = User()
user.set_id(1)  # user._User__id == 1
user.set_name("New Name")  # user._User__name == "New Name"
```

© Copyright 2021 to Shuntaro Shimizu, under the MIT license
executeline 0.1.1
Execute Callable Object in Line. ONE BY ONE.
License: MIT
Requires Python: >=3.7.*



# EXECUTELINE

---

### What does it do?

This Module Executes your Python Program "Callable Objects" one by one.

this module speedup your program. because focused  only one object at time.

### Quick Start

First must Install library with **pip**

```shell
pip install executeline
```

after installation must be **import** this library

```python
import executeline
```

 **or** if you need only **Exeline** module

```python
from executeline import Exeline
```

Now **executeline** ready to use .

lets initialize **Exeline** Get One Arguments name **run** type **bool**

```python
execute = Exeline()		# run arguments default is True
```

> **argument run** :
>
> > **True** mean **run method** called after every add to line.
> >
> > **False** mean when the **run method** is called.

lets connected **return signal**

```python
show_me = lambda *x: print(f"PocketIndex: {x[0]}\tName: {x[1]}\tObjectName: {x[2]}\tReturnEx{x[-1]}")
execute.Return_Connect(show_me)		# Connect To Callable Object Return Signal Manager
```

now must append **Callable Objects** and **Arguments** into The **pocket**

for this you have One method with Tow **namespace**  !

```python
# Append To Pocket Method
execute.append_pocket("MyObj", dosomething, (10, 15), {'NameOnlyArgu': 'Hello', 'other': 'World'})

# Other Name For Appending To Packet
execute.to_line("MyObj", dosomething, (10, 15), {'NameOnlyArgu': 'Hello', 'other': 'World'})
```

After Appending **object** to pocket **run method** is called and execute **object** in line.

other example with **run** is **False** and use **iteration**

```python
execute = Exeline(False)	# run is False
# Append To Pocket
execute.append_pocket("MyObj", dosomething, (10, 15), {'NameOnlyArgu': 'Hello', 'other': 'World'})
# Iteration
itex = iter(execute)
# Execute first Object
ex = next(itex)
```

example wait for call **run method**

```python
# Initialize Exeline
execute = Exeline(False)	# run is False
# Connect Return Signal
show_me = lambda *x: print(f"PocketIndex: {x[0]}\tName: {x[1]}\tObjectName: {x[2]}\tReturnEx{x[-1]}")
execute.Return_Connect(show_me)
# Append To Pocket
execute.append_pocket("MyObj", dosomething, (10, 15), {'NameOnlyArgu': 'Hello', 'other': 'World'})
# Iteration
execute.run()
```

---

### Exeline Map

![image-exelinemap](E:\LittleProject\ExecLine\exemap.png)

---