semvec/pypi-packages huggingface dataset:
timelab 1.0
Python time engine.
Keywords: python, time, engine, lab, timelab, datetime, date, time, manager


# TimeLab
This library handles everything related to time, Heres an example of how to use this library:

```python
from timelab import TimeSpan

timespan = TimeSpan(minutes=100)
print(timespan.seconds)  # Output: 0
print(timespan.minutes)  # Output: 100
print(timespan.hours)    # Output: 0

# Find total
print(timespan.total_seconds())  # Output: 6000
print(timespan.total_minutes())  # Output: 100
print(timespan.total_hours())    # Output: 1.6~

# Add time
print(TimeSpan(minutes=100) + TimeSpan(minutes=30))  # Output: TimeSpan(130 minutes)

# Subtract time
print(TimeSpan(minutes=100) - TimeSpan(minutes=30))  # Output: TimeSpan(70 minutes)

# Normalize time
# Normalize() will normalize the time format to make it more readable
print(TimeSpan(seconds=125).normalize())  # Output: TimeSpan(2 minutes, 5 seconds)
print(TimeSpan(hours=2.5).normalize())  # Output: TimeSpan(2 hours, 30 minutes)

# Get time as dictionary
print(TimeSpan(hours=2.5).as_dictionary())  # Output: {'hours': 2.5, 'centuries': 0.0, 'years': 0.0, ...}
print(TimeSpan(hours=2.5).as_dictionary())  # Output: {'hours': 2.5, 'centuries': 0.0, 'years': 0.0, ...}

# As datetime
print(TimeSpan(hours=2.5).as_datetime())  # Output: DateTime(2.5 hours)
```

And usage for datetime:

```python
from timelab import DateTime, TimeSpan

# Timestamp
print(DateTime.now().timestamp())  # Output format: Year-Month-Day

# Timestamp with custom format
print(DateTime.now().timestamp(time_format='Year: %Y, Month: %M, Day: %D'))  # Output format: Year: Year, Month: Month, Day: Day

# As timespan
print(DateTime.now().as_timespan())

# Add and subtract timespan to datetime
print(DateTime.now() + TimeSpan(minutes=30))
print(DateTime.now() - TimeSpan(minutes=30))

# Get difference between 2 datetimes
print(DateTime.now() - DateTime.now())  # Returns the difference as a timespan
```
uai 0.0.1
Package configuration example using bleeding edge toolset.
Requires Python: >=3.11

# uai
This package allows to quickly initialise new Python package using bleeding edge tools like linters, just run:
- `pip install uai`
- `uai <your-package-name>`

Now you are able to:
- `cd <your-package-name>`
- `make check    # To run tests and linters`
- `make publish  # To publish your new package to PyPi.org to make it accessable to everyone`

This is also a boilerplate for a new python package, so you can create a new package this way as well:
- `git clone git@github.com:albertas/uai.git <your-package-name>`
- `cd <your-package-name>`
- `make init <your-package-name>` - to start your modern package.

## Development
Commonly used commands for package development:
- `make check` - run unit tests and linters.
- `make fix` - format code and fix detected fixable issues.
- `make publish` - publishes current package version to pypi.org.
- `make compile` - bump and freeze dependency versions in requirements*.txt files
- `make sync` - upgrade installed dependencies in Virtual Environment (executed after `make compile`)

## Toolset
This package uses these cutting edge tools:
- ruff - for linting and code formatting
- mypy - for type checking
- pip-audit - for known vulnerability detection in dependencies
- deadcode - for unused code detection
- pytest - for collecting and running unit tests
- coverage - for code coverage by unit tests
- hatch - for publishing package to pypi.org
- uv - for Python virtual environment and dependency management
- pyproject.toml - configuration file for all tools
- Makefile - aliases for commonly used command line commands

## Feature requests:
- Newly installed package could have virtualenv initialised.
- Check if `git` is available before trying to initialise the repository.
- remove init Makefile alias and cli.py command python files.
- make a cli command: this package should be installable. Ideally this flow should work:
  - `pip install uai`
  - `uai mynewpackage`
  - `cd mynewpackage` && `make check` && `make publish`
- Add pre-commit hooks with all the tools enabled.
- codspeed.io could be considered for Continuous integration pipeline
hiphive 1.4
High-order force constants for the masses

hiPhive
=======

**hiPhive** is a tool for efficiently extracting high-order force constants from atomistic simulations, most commonly density functional theory calculations.
A detailed description of the functionality provided as well as an extensive tutorial can be found in the `user guide <https://hiphive.materialsmodeling.org/>`_.
Complete examples of using **hiphive** for force constants extraction can be found in the `hiphive-examples repository <https://gitlab.com/materials-modeling/hiphive-examples/>`_.

**hiPhive** is written in Python, which allows easy integration with countless first-principles codes and analysis tools accessible in Python, and allows for a simple and intuitive user interface.
For example using the following snippet one can train a force constant potential:

.. code-block:: python

   cs = ClusterSpace(primitive_cell, cutoffs)
   sc = StructureContainer(cs, list_of_training_structure)
   opt = Optimizer(sc.get_fit_data())
   opt.train()
   fcp = ForceConstantPotential(cs, opt.parameters)

after which it can be used in various ways, e.g., for generating phonon dispersions, computing phonon lifetimes, or running molecular dynamics simulations.

For questions and help please use the `hiphive discussion forum on matsci.org <https://matsci.org/hiphive>`_.
**hiPhive** and its development are hosted on `gitlab <https://gitlab.com/materials-modeling/hiphive>`_.


Installation
------------

**hiPhive** can be installed via `pip`::

    pip3 install hiphive

or via `conda <https://anaconda.org/conda-forge/hiphive>`_::

    conda install -c conda-forge hiphive

**hiPhive** requires Python3 and invokes functionality from several external libraries including the
`atomic simulation environment <https://wiki.fysik.dtu.dk/ase>`_,
`scikit-learn <http://scikit-learn.org/>`_,
`spglib <https://atztogo.github.io/spglib/>`_,
`SymPy <http://www.sympy.org/en/index.html>`_, and
`trainstation <https://trainstation.materialsmodeling.org/>`_.
Please consult the `installation section of the user guide <https://hiphive.materialsmodeling.org/installation.html>`_ for details.


Credits
-------

**hiPhive** has been developed at the `Department of Physics <https://www.chalmers.se/en/departments/physics/Pages/default.aspx>`_ of `Chalmers University of Technology <https://www.chalmers.se/>`_ (Gothenburg, Sweden) in the `Condensed Matter and Materials Theory division <http://www.materialsmodeling.org>`_.

When using **hiPhive** in your research please cite the following paper:

| Fredrik Eriksson, Erik Fransson, and Paul Erhart
| *The Hiphive Package for the Extraction of High‐Order Force Constants by Machine Learning*
| Adv. Theory. Sim., 1800184 (2019)
| `doi: 10.1002/adts.201800184 <https://doi.org/10.1002/adts.201800184>`_

Please consult the `Credits <https://hiphive.materialsmodeling.org/credits>`_ page of the documentation for additional references.
vickie 0.3.0
THe All-in-One Validator.
Requires Python: <4.0,>=3.10

<div align="center">
  <img src="./logo.png" alt="Logo" width="200">
  <h1>Vickie</h1>
  <p>THe All-in-One Validator.</p>
  <a href="https://github.com/walidsa3d/actions/workflows/test.yml">
    <img src="https://img.shields.io/github/actions/workflow/status/walidsa3d/vickie/test.yml?branch=main&style=flat-square" alt="Test Status">
  </a>
  <a href="https://github.com/walidsa3d/vickie/blob/main/LICENSE">
    <img src="https://img.shields.io/github/license/vickie/stamper?style=flat-square" alt="License">
  </a>
</div>


**vickie** is a versatile Python library for validating various types of inputs, including URLs, phone numbers, credit cards, and more. It's designed to be easy to use and integrate into your projects, helping ensure that user inputs are accurate and conform to expected formats.

## Features

- **URL Validation**: Check if a given string is a valid URL.
- **Phone Number Validation**: Validate phone numbers based on international formats.
- **Credit Card Validation**: Verify the validity of credit card numbers using Luhn's algorithm.
- **Email Address Validation**
- **Product ID Validation**

## Installation

You can install vickie via pip:

```bash
pip install vickie
```

## Example Usage

```python
from vickie import Vickie
is_phone_number = Vickie.is_phone("+14155552671", "US")
```

## 🧑‍💻 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📄 License
This project is licensed under the MIT License. See the LICENSE file for more details.