semvec/pypi-packages huggingface dataset:
mrflagly 0.2.14
No nonsense feature flagging system
Requires Python: >=3.10

# Introduction

Feature flagging should not be so complicated.

Mr Flagly is a decentralized feature flagging system written in Rust with bindings for other languages.

It does not depend on third party services or require you to deploy services and databases to manage.

Supported feature flag definition sources:

- URL
- JSON Value
- Environment Variable


## Rust usage

Setup your flag service:

```rust
use mrflagly::service::{FlagService, FlagServiceOptions};
let flag_service = FlagService::new(FlagServiceOptions {
    finder_type: mrflagly::service::types::FlagFinderType::URL,
    url: "https://path/to/hosted/json/file",
    refresh_interval: 600,
    data: None,
    env_var: None,
})
```

Then, to check for feature flag:

```rust
if flag_service.enabled("feature_x", false /* default value */, Some(HashMap::from([(String::from("user_id"), String::from("123")),])) /* optional context */) {
    // do something
}
```


## Python support

```python
import mrflagly

flag_service = mrflagly.FlagService(url="https://path/to/hosted/json/file")
if flag_service.enabled("feature_x", default=False, context={"foo": "bar"}):
    # do something
```


## FlagService constructor parameters

- `finder_type`: (NULL, URL, JSON, ENVVAR)
- `url`: URL to download feature flag json data
- `refresh_interval`: How often to poll the feature flag data endpoint
- `data`: Instead of hosting feature flag data from URL, you can provide it as a json blob
- `env_var`: Provide feature flag data in environment variable



## JSON format

JSON format for feature flag data:

```json
{
    "my_feature": {
        "rollout": 100
    },
    "my_feature_with_variants": {
        "rollout": 0,
        "variants" {
            "user_id": ["123"],
            "company_id": ["123"]
        }
    }
}
```


## Example activating for a particular customer

JSON config data:

```json
{
    "feature": {
        "rollout": 0,
        "variants": {
            "customer_id": ["123"]
        }
    }
}
```


Usage:
```python
import mrflagly
import json

flag_service = mrflagly.FlagService(
    data=json.dumps({"feature": {"rollout": 0, "variants": {"customer_id": ["123"]}}}))

if flag_service.enabled("feature_x", default=False, context={"customer_id": "123"}):
    # do something
```
midir 1.2.0
midir is a Python library designed to handle relative module dependencies by 
Requires Python: >=3.9

# midir

A library for resolving relative module dependencies.

# Description

`midir` is a Python library designed to handle relative module dependencies by resolving directory paths in an intelligent and system-agnostic way. This library can be used to introspect the file structure of your project and manipulate Python's `sys.path`, allowing for dynamic module imports based on directory hierarchy. It is especially helpful for larger projects where file structure can become complex and static imports cumbersome to manage. 

## Features

1. `midir(path: str) -> str:` Returns the directory name of the given file or directory path.

2. `get_caller() -> str:` Returns the name of the file or the location (directory) where the current execution point is present.

3. `mipath(path: str = None) -> str:` Returns the canonical (absolute) path of the current execution point or a provided path.

4. `midir(path: str = None) -> str:` Returns the directory name where the current execution point is or from a provided path.

5. `root_levels(levels: int = 1) -> None:` Makes directories available for import by adding them to sys.path. It starts from directory of the caller file and move up the directory hierarchy. The number of levels up to move is determined by input argument.

6. `root_suffix(suffix: str) -> None:` Similar to `root_levels`, but instead of moving up a certain number of directories, it continues to move up until it finds a directory whose name ends with the provided suffix and adds that directory to sys.path.

7. `lsdir(path: str) -> List[str]:` This function retrieves a sorted list of file and/or folder names from a specified directory path. Whether it returns file or folder names depends on the parameters set. It returns the full path of these files/folders if requested. Custom filter conditions can be applied. Raises errors if path isn't found or if no output requirements are specified. A warning is given if both file and folder parameters are set to true while a custom filter function is also specified.

## Exceptions

1. `FolderNotFoundError:` Custom exception raised when no folder matching the required conditions (in `root_suffix`) is found in the directory hierarchy.

## Build instructions

1. Building the package before uploading: 'python -m build' (from "midir").
2. Upload the package to pypi: 'python -m twine upload --repository pypi dist/*'
3. Install the package from pypi: 'python -m pip install midir'
4. If any dependencies are required, edit the `pyproject.toml` file, "\[project\]" field, and add a `dependencies` key with a `List\[str\]` value, where each string is a `pip`-readable dependency.
atsphinx-stlite 0.2.1
Embed Stlite frame into Sphinx documentation.
Requires Python: >=3.10

===============
atsphinx-stlite
===============

Embed Stlite frame into Sphinx documentation.

Overview
========

This is Sphinx extension to provide directive
to render Streamlit application on document using Stlite.

When you use this, your document will display interactive contents.

Example
=======

This is example to display table from pandas DataFrame.

.. code:: rst

   .. stlite::

      import streamlit as st
      import pandas as pd

      df = pd.DataFrame({
          'first column': [1, 2, 3, 4],
          'second column': [10, 20, 30, 40]
      })

      st.write(df)

If you want to know how does it display,
go to `demo page of document <https://atsphinx.github.io/stlite/en/examples/pandas-dataframe/>`_.

Usage
=====

1. Install from PyPI (e.g. ``pip install atsphinx-stlite`` )
2. Add ``atsphinx.stlite`` to ``extensions`` in ``conf.py`` of your document.
3. Write contents refer to `documents <https://atsphinx.github.io/stlite/en/>`_.
4. Build your document using HTML-based builders (e.g. ``make html`` )
5. Show it!

For contributing
================

*Do you have a feedback to this?*

When you want to contribute to this project,
please follow the `atsphinx's common contributing guide <https://atsphinx.github.io/en/contributing/>`_.

License
=======

This project is licensed under the Apache License 2.0.
See `it <https://github.com/atsphinx/stlite/blob/main/LICENSE>`_.
pydantic-zarr 0.9.1
Pydantic models for the Zarr file format
Requires Python: >=3.11
Keywords: pydantic, zarr

# pydantic-zarr

[![PyPI](https://img.shields.io/pypi/v/pydantic-zarr)](https://pypi.python.org/pypi/pydantic-zarr)

[Pydantic](https://docs.pydantic.dev/latest/) models for [Zarr](https://zarr.readthedocs.io/en/stable/index.html).

## Installation

```sh
pip install -U pydantic-zarr
# or, with zarr i/o support
pip install -U "pydantic-zarr[zarr]"
```

## Getting help

- Docs: see the [documentation](https://pydantic-zarr.readthedocs.io/) for detailed information about this project.
- Chat: We use [Zulip](https://ossci.zulipchat.com/#narrow/channel/423692-Zarr) for project-related chat.

## Example

```python
import zarr
from pydantic_zarr import GroupSpec

group = zarr.group(path='foo')
array = zarr.create(store = group.store, path='foo/bar', shape=10, dtype='uint8')
array.attrs.put({'metadata': 'hello'})

# this is a pydantic model
spec = GroupSpec.from_zarr(group)
print(spec.model_dump())
"""
{
    'zarr_format': 2,
    'attributes': {},
    'members': {
        'bar': {
            'zarr_format': 2,
            'attributes': {'metadata': 'hello'},
            'shape': (10,),
            'chunks': (10,),
            'dtype': '|u1',
            'fill_value': 0,
            'order': 'C',
            'filters': None,
            'dimension_separator': '.',
            'compressor': {
                'id': 'blosc',
                'cname': 'lz4',
                'clevel': 5,
                'shuffle': 1,
                'blocksize': 0,
            },
        }
    },
}
"""
```

## History

This project was developed at [HHMI / Janelia Research Campus](https://www.janelia.org/). It was originally written by Davis Bennett to solve problems he encountered while working on the [Cellmap Project team](https://www.janelia.org/project-team/cellmap/members). In December of 2024 this project was migrated from the [`janelia-cellmap`](https://github.com/janelia-cellmap) github organization to [`zarr-developers`](https://github.com/zarr-developers) organization.