semvec/pypi-packages huggingface dataset:
qocttools 0.0.14
A set of tools to do quantum optimal control calculations
Requires Python: >=3.9


qocttools is a python package that implements quantum
optimal control theory (QOCT). 

You may download it from its `gitlab page <https://gitlab.com/acbarrigon/qocttools>`_.
Documentation `here <https://qocttools.readthedocs.io/>`_.

It solves typical optimization problems defined on generic quantum systems. These
may be closed (described by the Schrödinger equation) or open (described by Lindblad's equation).
It relies heavily on the `QuTiP <https://qutip.org/>`_ program to handle internally
the quantum objects representation, manipulation, etc., and on the `nlopt <https://nlopt.readthedocs.io/en/latest/>`_
library for function optimization algorithms.
datalogd 0.4.2
A data logging daemon, easily customisable using a flexible plugin system.
Requires Python: >=3.7

datalogd - A Data Logging Daemon
================================

datalogd is a data logging daemon service which uses a source/filter/sink plugin architecture to
allow extensive customisation and maximum flexibility. There are no strict specifications or
requirements for data types, but typical examples would be readings from environmental sensors such
as temperature, humidity, voltage or the like.

The user guide and API documentation can be read online at `Read the Docs
<https://datalogd.readthedocs.io/>`_. Source code is available on `GitLab
<https://gitlab.com/ptapping/datalogd>`_.

Custom data sources, filters, or sinks can be created simply by extending an existing
``DataSource``, ``DataFilter``, or ``DataSink`` python class and placing it in a plugin directory.

Data sources, filters, and sinks can be arbitrarily connected together with a connection digraph
described using the `DOT graph description language
<https://en.wikipedia.org/wiki/DOT_(graph_description_language)>`_.

Provided data source plugins include:
  * ``LibSensorsDataSource`` - (Linux) computer motherboard sensors for temperature, fan speed,
    voltage etc.
  * ``SerialDataSource`` - generic data received through a serial port device. Arduino code for
    acquiring and sending data through its USB serial connection is also included.
  * ``RandomWalkDataSource`` - testing or demonstration data source using a random walk algorithm.
  * ``ThorlabsPMDataSource`` - laser or light power measurement using the Thorlabs PM100 or PM400
    power meter.
  * ``PicoTC08DataSource`` - thermocouple or other sensor measurements using the Pico Technologies
    TC-08 USB data logger.

Provided data sink plugins include:
  * ``PrintDataSink`` - print to standard out or standard error streams.
  * ``FileDataSink`` - write to a file.
  * ``LoggingDataSink`` - simple output to console using python logging system.
  * ``InfluxDB2DataSink`` - InfluxDB 2.x database system specialising in time-series data.
  * ``MatplotlibDataSink`` - create a plot of data using matplotlib.
  * ``PyqtgraphDataSink`` - plot incoming data in realtime in a pyqtgraph window.

Provided data filter plugins include:
  * ``SocketDataFilter`` - bridge a connection over a network socket.
  * ``KeyValDataFilter`` - selecting or discarding data entries based on key-value pairs.
  * ``TimeStampDataFilter`` - adding timestamps to data.
  * ``AggregatorDataFilter`` - aggregating multiple data readings into a fixed-size buffer.
  * ``CSVDataFilter`` - format data as a table of comma separated values.
  * ``PolynomialFunctionDataFilter`` - apply a polynomial function to a value.
  * ``FlowSensorCalibrationDataFilter`` - convert a pulse rate into liquid flow rate.
  * ``CoolingPowerDataFilter`` - calculate power dissipation into a liquid using temperatures and
    flow rate.

See the Data Logging Recipes section in the documentation for examples of how to link various data
sources, filters, and sinks to make something useful.
pysmsgateway 0.1.0
A Python library for sending SMS messages via a custom gateway


    pysmsgateway is a Python library that provides an interface for sending SMS messages 
    via a gateway using the Traccar SMS Gateway Android application. It allows developers 
    to send SMS messages programmatically from Python code to recipient mobile numbers, 
    using a custom phone number as a reply number to the gateway.

    ### Features:
    - Single SMS sending to a recipient.
    - Bulk SMS sending to multiple recipients.
    - Integration with systems requiring SMS functionality (e.g., 2FA).
    
    ### Important Notice:
    - Download the Traccar Android Application from the playstore.
    - For Local Connection, makesure you are on the same network with the Android phone which has traccar sms gateway application.
    - Go to Settings, collect the IP Address of the phone and the api token.
    - Use the token and the IP and indicated in the example.
    - For more information on traccar sms gateway application to visit [Documentation](https://www.traccar.org/documentation/)
    ### Example Usage:
    ```python
    from pysmsgateway import pysmsgateway

    # Initialize the gateway
    gateway = pysmsgateway(token='your_token', ip='your phone's ip', sms_token='your_sms_token')

    # Sending a single message
    gateway.send_sms('recipient_number', 'Hello, World!')

    # Sending different messages to different recipients
    data = {
        'recipient1': 'Message 1',
        'recipient2': 'Message 2',
        'recipient3': 'Message 3'
    }
    gateway.send_sms(data)

    # Sending a single message to multiple recipients
    numbers = ['recipient1', 'recipient2', 'recipient3']
    gateway.send_sms('Single message to multiple recipients', numbers)
    ```
    For more information visit [Github](https://github.com/ThomsonKaisi/pysmsgateway)