semvec/pypi-packages huggingface dataset:
authtestpkg1.0.0 1.0.3
Module for authentication pkg test
Requires Python: >=3.12

# Authentication Module

The Authentication Module is a Python library that handles user authentication and token management. It supports obtaining and refreshing access tokens, and handling various exceptions that might occur during the authentication process.

## Features

- Obtain access tokens using username and password
- Methods exposed get_token() and get_refresh_token()
- Refresh access tokens using a refresh token.
- Handle errors such as invalid credentials, token request errors, and DNS resolution errors.
- Supports Proxy Functionality

## Installation

You can install the package using pip. Ensure you have Python 3.12+ installed.

```sh
! pip install authtestpkg1.0.0==1.0.2
```
# Usage
## 1.get_token Usage
Here's a brief example of how to use this get_token from this package:
```sh
from Authentication.services.impl.sdk_authenticate_service_impl import User

# Create a User instance
user = User()

# Get an access token using username and password
username = "your_username"
password = "your_password"
token_response = user.get_token(username, password)

print(token_response) # whole JSON response

#For getting access token from token_response
print(token_response.get("access_token"))
```
## 2.get_refresh_token Usage
```sh
from Authentication.services.impl.sdk_authenticate_service_impl import User

user = User()
refresh_token = "your_refresh_token"
new_token_response = user.get_refresh_token(refresh_token)

#For getting access token from new_token_response
print(new_token_response.get("access_token"))

print(new_token_response)
```

## Using a Proxy
If you need to use a proxy server for your authentication requests, you can pass an SDKProxy instance to the get_token or get_refresh_token methods.
```sh
from Authentication.services.impl.sdk_authenticate_service_impl import User
from Authentication.model.sdk_proxy import SDKProxy as AuthSDKProxy

# Create a User instance
user = User()

# Initialize proxy settings (if needed) 
auth_sdk_proxy = AuthSDKProxy( proxy_username="", proxy_password="", proxy_host=None, proxy_port=None, proxy_domain="" )

# Get an access token using username, password, and proxy
username = "your_username"
password = "your_password"
token_response = user.get_token(username, password, auth_sdk_proxy)
print(token_response)

#For getting access token from token_response
print(token_response.get("access_token"))

refresh_token_response=user.get_refresh_token("your_refresh_token",auth_sdk_proxy)
print(refresh_token_response)

#For getting access token from refresh_token_response
print(token_response.get("access_token"))

```

# Configuration
By default, the config is set to Prod URL's. To give preference, supports the custom-properties file. For that, Should create a properties file with Naming of "config/custom-authenticate-config.properties".
```sh
config/sdk_application.properties
```
wrench-build 0.1.9
Build C files without checking all its dependencies
Requires Python: >=3.8

# :wrench: wrench

[![Rye](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/rye/main/artwork/badge.json)](https://rye.astral.sh)

A simple build utility for your C project.

```bash
rye install wrench-build
# or if you don't mind polluting the environment
pip install wrench-build
```

## Why and how

Consider a simple project:

```
decode.h decode.c
emulate.c
execute.c execute.h
fetch.c fetch.h
instr.h
register.c register.h
utils.c utils.h
```

The dependency graph looks like this:

![dependencies](https://github.com/xiaoshihou514/wrench/assets/108414369/7f282e97-adb7-4940-ba95-18df1fafc4a8)

To build it manually, you have to run:

```bash
gcc -c execute.c -o out/execute.o
gcc -c fetch.c -o out/fetch.o
gcc -c register.c -o out/register.o
gcc -c utils.c -o out/utils.o
gcc -c decode.c -o out/decode.o
gcc -c emulate.c -o out/emulate.o
gcc out/execute.o out/fetch.o out/register.o out/utils.o out/decode.o out/emulate.o -o emulate
```

That's very error prone and also gets really boring after a while, you may want to write a make file (or maybe tell chatgpt to write it).

```make
CC = gcc

OBJDIR = out
SRCDIR = .
SRC = $(SRCDIR)/execute.c $(SRCDIR)/fetch.c $(SRCDIR)/register.c \
      $(SRCDIR)/utils.c $(SRCDIR)/decode.c $(SRCDIR)/emulate.c
OBJ = $(OBJDIR)/execute.o $(OBJDIR)/fetch.o $(OBJDIR)/register.o \
      $(OBJDIR)/utils.o $(OBJDIR)/decode.o $(OBJDIR)/emulate.o
TARGET = emulate
all: $(TARGET)
$(TARGET): $(OBJ)
	$(CC) $(OBJ) -o $(TARGET)
$(OBJDIR)/%.o: $(SRCDIR)/%.c
	$(CC) -c $< -o $@
clean:
	rm -f $(OBJ) $(TARGET)
```

Let's be honest, this is very hard to read and very cumbersome to write. Since C compiling follows simple rules, we can automate this. To do the same thing with wrench-build, just run `wrb emulate` to tell it what you want it to generate.

```
CC=gcc
CFLAGS=
Trying to build out/execute.o
gcc -c execute.c -o out/execute.o
Trying to build out/utils.o
gcc -c utils.c -o out/utils.o
Trying to build out/decode.o
gcc -c decode.c -o out/decode.o
Trying to build out/register.o
gcc -c register.c -o out/register.o
Trying to build out/fetch.o
gcc -c fetch.c -o out/fetch.o
Trying to build out/emulate.o
gcc -c emulate.c -o out/emulate.o
Trying to build emulate
gcc out/execute.o out/utils.o out/decode.o out/register.o out/fetch.o out/emulate.o -o emulate
```

Now `wrb` will read all your files and sort out the includes and give you the output. :tada:

OK, now that we can compile stuff easily we may wish to run something, maybe `valgrind` or a linter, or just some tests.

You can write a `Wrenchfile`, the full supported fields are listed below:

```
CC = clang
MY_VAR = -Iheaders
CFLAGS = -Wall -Werror -g $(MY_VAR)
BUILD = target1 target2
LIBDIRS = lib1 lib2 $(ERROR)
LIB= map set hash
ERROR =lib3

SHELL= fish

main(nvim -l -): task1, task2
  vim.print({hello = "world"})

task1(): task2
  set foo ${CFLAGS}
  echo $foo

task3(bash):
 if [ ${SHELL} == "lib3" ]; then
     echo ${SHELL}
 fi

task2():
  echo "fish"
```
cairocffi 1.7.1
cffi-based cairo bindings for Python
Requires Python: >=3.8
Keywords: cairo, cffi, binding

cairocffi is a `CFFI`_-based drop-in replacement for Pycairo_,
a set of Python bindings and object-oriented API for cairo_.
Cairo is a 2D vector graphics library with support for multiple backends
including image buffers, PNG, PostScript, PDF, and SVG file output.

Additionally, the ``cairocffi.pixbuf`` module uses GDK-PixBuf_
to decode various image formats for use in cairo.

.. _CFFI: https://cffi.readthedocs.org/
.. _Pycairo: https://pycairo.readthedocs.io/
.. _cairo: http://cairographics.org/
.. _GDK-PixBuf: https://gitlab.gnome.org/GNOME/gdk-pixbuf

* Free software: BSD license
* For Python 3.8+, tested on CPython and PyPy
* Documentation: https://doc.courtbouillon.org/cairocffi/
* Changelog: https://doc.courtbouillon.org/cairocffi/stable/changelog.html
* Code, issues, tests: https://github.com/Kozea/cairocffi
* Code of conduct: https://www.courtbouillon.org/code-of-conduct
* Professional support: https://www.courtbouillon.org
* Donation: https://opencollective.com/courtbouillon
* API partially compatible with Pycairo.
* Works with any version of cairo.

cairocffi has been created and developed by Kozea (https://kozea.fr).
Professional support, maintenance and community management is provided by
CourtBouillon (https://www.courtbouillon.org).

Copyrights are retained by their contributors, no copyright assignment is
required to contribute to cairocffi. Unless explicitly stated otherwise, any
contribution intentionally submitted for inclusion is licensed under the BSD
3-clause license, without any additional terms or conditions. For full
authorship information, see the version control history.
banksy-py 0.0.7
Spatial Domain analysis using Banksy.
Requires Python: >=3.8

 # Banksy

This package wraps Banksy so it can be installed and used using PyPI.

All Banksy credit goes to the Banksy authors. Please check the original publication for more details: [Nature Article](https://www.nature.com/articles/s41588-024-01664-3).

If you use this package, please cite the original Banksy publication.
jaraco.docker 2.3.0
Docker facilities
Requires Python: >=3.8

.. image:: https://img.shields.io/pypi/v/jaraco.docker.svg
   :target: https://pypi.org/project/jaraco.docker

.. image:: https://img.shields.io/pypi/pyversions/jaraco.docker.svg

.. image:: https://github.com/jaraco/jaraco.docker/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.docker/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. .. image:: https://readthedocs.org/projects/PROJECT_RTD/badge/?version=latest
..    :target: https://PROJECT_RTD.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2024-informational
   :target: https://blog.jaraco.com/skeleton

Usage
=====

To determine if the current environment is running in docker::

	from jaraco.docker import is_docker
	is_docker()
ape-pie 0.2.0
A small API client abstraction layer on top of requests.
Requires Python: >=3.9
Keywords: api client, requests

Ape-pie client
==============

.. pull-quote:: Monkey see, monkey GET.

|build-status| |code-quality| |black| |coverage| |docs|

|python-versions| |pypi-version|

Ape-pie is a small API client abstraction layer on top of requests_.

.. contents::

.. section-numbering::

Features
========

* No leaky abstraction - use the familiar ``requests`` Python interfaces.
* Modular configuration adapters for your project's domain(s).
* Highly customizable for your needs.

Installation and usage
======================

Quickstart and API reference documentation are hosted on ReadTheDocs_.


.. |build-status| image:: https://github.com/maykinmedia/ape-pie/workflows/Tests%20and%20PyPI%20publishing/badge.svg
    :alt: Build status
    :target: https://github.com/maykinmedia/ape-pie/actions?query=workflow%3A%22Tests+and+PyPI+publishing%22

.. |code-quality| image:: https://github.com/maykinmedia/ape-pie/workflows/Linting%20and%20code%20quality/badge.svg
     :alt: Code quality checks
     :target: https://github.com/maykinmedia/ape-pie/actions?query=workflow%3A%22Linting+and+code+quality%22

.. |black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

.. |coverage| image:: https://codecov.io/gh/maykinmedia/ape-pie/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/maykinmedia/ape-pie
    :alt: Coverage status

.. |docs| image:: https://readthedocs.org/projects/ape-pie/badge/?version=latest
    :target: https://ape-pie.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. |python-versions| image:: https://img.shields.io/pypi/pyversions/ape-pie.svg

.. |pypi-version| image:: https://img.shields.io/pypi/v/ape-pie.svg
    :target: https://pypi.org/project/ape-pie/

.. _requests: https://docs.python-requests.org/en/latest/index.html
.. _ReadTheDocs: https://ape-pie.readthedocs.io/en/latest/
drtk 100.0.0
sdfsdf sdafaf safafa sfsdf



# Installation


To install requirements: `python -m pip install requirements.txt`

To save requirements: `python -m pip list --format=freeze --exclude-editable -f https://download.pytorch.org/whl/torch_stable.html > requirements.txt`

* Note we use Python 3.9.4 for our experiments

# Running the code 

For remaining experiments: 

Navigate to the corresponding directory, then execute: `python run.py -m` with the corresponding `config.yaml` file (which stores experiment configs).

# License

Consult License.md
nandanisamplepackage 0.0.3
A small example package
Requires Python: >=3.8

# Calculator Project

## Project Description

The **Calculator Project** is a simple yet powerful calculator application written in Python. It supports basic arithmetic operations such as addition, subtraction, multiplication, and division. The project is designed to provide an easy-to-use interface for performing quick calculations and serves as an educational tool for those learning Python programming.

## Features

- **Addition**: Add two numbers.
- **Subtraction**: Subtract one number from another.
- **Multiplication**: Multiply two numbers.
- **Division**: Divide one number by another.
- **Command-line Interface**: Perform calculations directly from the terminal.

## Installation

Requires Python 3.7 or higher.

1. **Clone the Repository**:
    ```bash
    git clone https://github.com/yourusername/calculator.git
    ```

2. **Navigate to the Project Directory**:
    ```bash
    cd calculator
    ```

3. **Install Dependencies** (if any):
    ```bash
    pip install -r requirements.txt
    ```

## Usage

### Command-line Usage

You can use the calculator directly from the command line.

1. **Run the Calculator**:
    ```bash
    python calculator.py
    ```

2. **Perform Operations**:
    ```bash
    # Example: Addition
    python calculator.py add 2 3
    # Output: 5
    ```
![Demo](https://media3.giphy.com/media/aUovxH8Vf9qDu/giphy.gif)
### Example Code

You can also use the calculator functions in your Python code.

```python
from calculator import add, subtract, multiply, divide

# Perform addition
result = add(10, 5)
print(f"10 + 5 = {result}")

# Perform subtraction
result = subtract(10, 5)
print(f"10 - 5 = {result}")

# Perform multiplication
result = multiply(10, 5)
print(f"10 * 5 = {result}")

# Perform division
result = divide(10, 5)
print(f"10 / 5 = {result}")