semvec/pypi-packages huggingface dataset:
quiltz-messaging 0.3.3
A messaging utility module for python

# quiltz-messaging

python (email) messaging package 

## Purpose

At QWAN, we're building some applications in python. We collect useful stuff in
quiltz packages:

* [**quiltz-domain**](https://github.com/qwaneu/quiltz-domain) contains domain
  level modules like, entity id's, results, an email anonymizer, validators and
  parsers
* [**quiltz-testsupport**](https://github.com/qwaneu/quiltz-testsupport)
  contains test support modules, that supports mainly non unit tests, like
  integrating with smtp, probing asynchronous results and asserting log
  statements
* **quiltz-messaging** (this package) contains a messaging domain concept and an
  engine(s) to send the messages. Currently, only smtp sending is supported.

## installing 

```bash
pip install quitlz-messaging
```

see [documentation](doc/index.md)
dkconverters 1.0.0
A package to convert between different numeral systems
Requires Python: >=3.6

# Package-dkconverter

- This package helps you to convert decimal numbers to other numeral system representations.
- File named **"conv.py"** has all the functions that do so.

## Getting started

### Install Package using pip
> pip install dkconverters==1.0.0

### Import package in your pyfile
```python
from dkconverter import conv
```
### Get More Info on Functions Used

For your reference info on functions used are added to readme and an Example Code is also added for reference.
```python
from dkconverter import conv
help(conv)
print(conv.bina(10))
print(conv.octl(10))
print(conv.hexdcml(10))
```

## Function-*bina*

It converts decimal number into binary number which is passed as an argument to this function.
===

## Function-*octl*

It converts decimal number into octal number which is passed as an argument to this function.
===

## Function-*hexdcml*

It converts decimal number into hexadecimal number which is passed as an argument to this function.
===
kali-ruby 1.102.2
A small example package
Requires Python: >=3.6


# Make sure you have upgraded version of pip
Windows
```
py -m pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```

## Create a project with the following structure
```
packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir tests
```

## pyproject.toml 

This file tells tools like pip and build how to create your project

```
[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"
```
build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.

build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.


# Setup.cfg setup
Using setup.cfg is a best practice, but you could have a dynamic setup file using setup.py

```
[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = src

```
# Running the build
### Make sure your build tool is up to date
Windows
```
py -m pip install --upgrade build
```
Linux/MAC OS
```
python3 -m pip install --upgrade build
```


### Create the build
```
py -m build
```













### References
https://packaging.python.org/tutorials/packaging-projects/
quiltz-testsupport 0.3.1
A testsupport utility module for python

# quiltz-testsupport

A package for test support

## Purpose

At [QWAN](https://www.qwan.eu) we're building some applications in python. We collect usefull stuff in quiltz packages:

* [**quiltz-domain**](https://github.com/qwaneu/quiltz-domain) contains domain
  level modules like, entity id's, results, an email anonymizer, validators and
  parsers
* **quiltz-testsupport** (this package) contains test support modules, that supports mainly non
  unit tests, like integrating with smtp,  probing asynchronous results and
  asserting log statements
* [**quiltz-messaging**](https://github.com/qwaneu/quiltz-messaging) contains a
  messaging domain concept and an engines to send the messages. Currently only
  smtp sending is supported.

## Modules in this package

### logging
With the logging module you can assert log statements in a test using the `log_collector` fixture:

#### in test:
```python
from quiltz.testsupport import log_collector
def test_logs_hello(log_collector):
    foo()
    log_collector.assert_info('hello info')
```

#### in production
```python
def foo():
    logger = logging.getLogger()
    logger.info('hello info')
```

### probing
With the probing module you can probe for async results:

```python
from hamcrest import assert_that, equal_to
from quiltz.testsupport import probe_that

def test_stub_server_collects_message_for_recepient(self):        
    message = aMessage(recipient='rob@mailinator.com', sender='no-reply@qwan.eu', subject='test', body='hello test')
    self.message_engine.send([message])
    
    probe_that(lambda: self.server.messages == [stringified_message(message)])
    # or
    probe_that(lambda: assert_that(self.server.messages, equal_to([
        stringified_message(message)
    ])))
    # or
    probe_that(lambda: self.server.messages, equal_to([
        stringified_message(message)
    ]))
```

### smtp
With the smtp module you can create a stub smtp server that collects smtp messages

```python
from hamcrest import assert_that, equal_to
from quiltz.testsupport import probe_that
def server()
    server = StubSmtpServer(hostname='localhost', port=9925)
    server.start()
    yield(server)
    server.stop()

def test_collects_message_for_recepient(self, server): 
    message_engine = SMTPClientForTest(host='localhost', port='9925')
    message = aMessage(recipient='rob@mailinator.com', sender='no-reply@qwan.eu', subject='test', body='hello test')
    message_engine.send([message])
    
    probe_that(lambda: assert_that(server.messages, equal_to([
        stringified_message(message)
    ])))
```

## installing 

```bash
pip install quiltz-testsupport
```