semvec/pypi-packages huggingface dataset:
objectfactory 0.2.0
objectfactory is a python package to easily implement the factory design pattern for object creation, serialization, and polymorphism

# py-object-factory

[![Build Status](https://github.com/devinaconley/py-object-factory/actions/workflows/test.yml/badge.svg)](https://github.com/devinaconley/py-object-factory/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/devinaconley/py-object-factory/branch/develop/graph/badge.svg)](https://codecov.io/gh/devinaconley/py-object-factory)
[![Documentation Status](https://readthedocs.org/projects/objectfactory/badge/?version=latest)](https://objectfactory.readthedocs.io/en/latest/?badge=latest)


**objectfactory** is a python package to easily implement the factory design pattern for object creation, serialization, and polymorphism
- designed to support polymorphism
- integrates seamlessly with [marshmallow](https://github.com/marshmallow-code/marshmallow)
  and other serialization frameworks
- schema inherent in class definition
- load any object with a generic interface
- serialize objects to JSON

## Example 
Simple **shapes** example:
```python
import objectfactory

@objectfactory.register
class Square(objectfactory.Serializable):
    side = objectfactory.Field()

    def get_area(self):
        return self.side * self.side

@objectfactory.register
class Triangle(objectfactory.Serializable):
    base = objectfactory.Field()
    height = objectfactory.Field()

    def get_area(self):
        return 0.5 * self.base * self.height

serialized_data = [
    {"_type": "Square", "side": 2.0},
    {"_type": "Triangle", "base": 1.75, "height": 2.50},
    {"_type": "Square", "side": 1.5},
]

for data in serialized_data:
    shape = objectfactory.create(data)
    print('class type: {}, shape area: {}'.format(type(shape), shape.get_area()))
```

Output:
```
class type: <class '__main__.Square'>, shape area: 4.0
class type: <class '__main__.Triangle'>, shape area: 2.1875
class type: <class '__main__.Square'>, shape area: 2.25
```

### More examples
See more advanced examples [here](https://github.com/devinaconley/py-object-factory/tree/develop/examples)

## Install
Use [pip](https://pip.pypa.io/en/stable/installing/) for installation
```
pip install objectfactory
```

## Documentation
Read the full documentation at [objectfactory.readthedocs.io](https://objectfactory.readthedocs.io/)
requests-unixsocket 0.4.1
Use requests to talk HTTP via a UNIX domain socket
Requires Python: >=3.9

requests-unixsocket
===================

.. image:: https://badge.fury.io/py/requests-unixsocket.svg
    :target: https://badge.fury.io/py/requests-unixsocket
    :alt: Latest Version on PyPI

.. image:: https://github.com/msabramo/requests-unixsocket/actions/workflows/ci-cd.yml/badge.svg?event=push
    :target: https://github.com/msabramo/requests-unixsocket/actions/workflows/ci-cd.yml

Use `requests <http://docs.python-requests.org/>`_ to talk HTTP via a UNIX domain socket

Usage
-----

Explicit
++++++++

You can use it by instantiating a special ``Session`` object:

.. code-block:: python

    import json

    import requests_unixsocket

    session = requests_unixsocket.Session()

    r = session.get('http+unix://%2Fvar%2Frun%2Fdocker.sock/info')
    registry_config = r.json()['RegistryConfig']
    print(json.dumps(registry_config, indent=4))


Implicit (monkeypatching)
+++++++++++++++++++++++++

Monkeypatching allows you to use the functionality in this module, while making
minimal changes to your code. Note that in the above example we had to
instantiate a special ``requests_unixsocket.Session`` object and call the
``get`` method on that object. Calling ``requests.get(url)`` (the easiest way
to use requests and probably very common), would not work. But we can make it
work by doing monkeypatching.

You can monkeypatch globally:

.. code-block:: python

    import requests_unixsocket

    requests_unixsocket.monkeypatch()

    r = requests.get('http+unix://%2Fvar%2Frun%2Fdocker.sock/info')
    assert r.status_code == 200

or you can do it temporarily using a context manager:

.. code-block:: python

    import requests_unixsocket

    with requests_unixsocket.monkeypatch():
        r = requests.get('http+unix://%2Fvar%2Frun%2Fdocker.sock/info')
        assert r.status_code == 200


Abstract namespace sockets
++++++++++++++++++++++++++

To connect to an `abstract namespace
socket <https://utcc.utoronto.ca/~cks/space/blog/python/AbstractUnixSocketsAndPeercred>`_
(Linux only), prefix the name with a NULL byte (i.e.: `\0`) - e.g.:

.. code-block:: python

    import requests_unixsocket

    session = requests_unixsocket.Session()
    res = session.get('http+unix://\0test_socket/get')
    print(res.text)

For an example program that illustrates this, see
``examples/abstract_namespace.py`` in the git repo. Since abstract namespace
sockets are specific to Linux, the program will only work on Linux.


See also
--------

- https://github.com/httpie/httpie-unixsocket - a plugin for `HTTPie <https://httpie.org/>`_ that allows you to interact with UNIX domain sockets