Saravanan666/pypi-org huggingface dataset:
Package: component-generator
Generate backend components quicklyFree software: BSD 2-Clause LicenseInstallationpip install component-generatorYou can also install the in-development version with:pip install https://github.com/onna/python-component-generator/archive/master.zipDocumentationhttps://python-component-generator.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2021-10-13)First release on PyPI.
Package: component-injector
component-injectorA modern component / dependency injector for python 3.6+.This library provides a framework-agnostic component (or dependency)
injector that injects registered components into your function calls.
The components to insert are identified by looking at the called
function argument annotations.When registering a component, all its base classes are registered as
well unless you explicitly disable that. You can also choose to only
register base classes that are not already registered with the
injector.It provides local scopes where you can register additional components
or override existing components. After exiting the scope, the registry
will return to the state it was in before entering the scope.Compatibilitycomponent-injectoris compatible with python 3.6+ using the
backportedcontextvarsanddataclassespackages.The scopes are thread-safe and when using python 3.7 also safe for for
use with asyncio tasks.Installationcomponent-injectoris available from pypi:pipinstallcomponent-injectorUsage exampleHere's a small demo on how to use the injector:from component_injector import Injector

injector = Injector()

class O:
    pass

@injector.inject
def consumer_of_o(o: O) -> None:
    print(o)

injector.register(O())
consumer_of_o()  # 'o' wil be the registered instance.

consumer_of_o(O())  # 'o' will be this new instance.For more examples and usage, please refer todemo.pyandasync_demo.py.Development setupFor development purposes, you can clone the repository and usepoetryto install and maintain the
dependencies. There is no test suite. The project comes with a set of
pre-commit hooks that can format (isort, black) and check your code
(mypy, flake8) automatically.gitclonegit@github.com:iksteen/component-injector.gitcdcomponent-injector
poetryrunpre-commitinstallRelease History1.1.1Fix incorrect type registration when not registering bases.Fix typo in documentation (thanks @trbs!).1.1.0Add documentation.Add support for component factories. Asynchronous factories are
supported as well when injecting into asynchronous functions.1.0.2Fix bug where already bound arguments were overwritten.1.0.1Fix links to examples.1.0.0Initial Release.MetaIngmar Steen –@iksteenDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/iksteen/ContributingFork it (https://github.com/iksteen/component-injector/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: componentize-py
componentize-pyABytecode AllianceprojectThis is a tool to convert a Python application to aWebAssembly
component.  It takes the
following as input:aWITfile or directorythe name of aWIT worlddefined in the above file or directorythe name of a Python module which targets said worlda list of directories in which to find the Python module and its dependenciesThe output is a component which may be run using
e.g.wasmtime.Getting StartedFirst, installPython 3.10 or laterandpipif you don't already have them.  Then,
installcomponentize-py:pipinstallcomponentize-pyNext, create or download the WIT world you'd like to target, e.g.:cat>hello.wit<<EOFpackage example:hello;world hello {export hello: func() -> string;}EOFIf you're using an IDE or just want to examine the bindings produced for the WIT
world, you can generate them using thebindingssubcommand:componentize-py-dhello.wit-whellobindings.Then, use thehellomodule produced by the command above to write your app:cat>app.py<<EOFimport helloclass Hello(hello.Hello):def hello(self) -> str:return "Hello, World!"EOFAnd finally generate the component:componentize-py-dhello.wit-whellocomponentizeapp-oapp.wasmSee theexamplesdirectories for more examples, including various ways to run the components you've
created.Known LimitationsCurrently, the application can only import dependencies during build time, which
means any imports used at runtime must be resolved at the top level of the
application module.  For example, ifxis a module with a submodule namedythe following may not work:importxclassHello(hello.Hello):defhello(self)->str:returnx.y.foo()That's because importingxdoes not necessarily resolvey.  This can be
addressed by modifying the code to importyat the top level of the file:fromximportyclassHello(hello.Hello):defhello(self)->str:returny.foo()This limitation is being tracked asissue
#23.Seethe issue trackerfor other known issues.ContributingSeeCONTRIBUTING.mdfor details on how to contribute to the project and build it from source.
Package: componentry
A new Zope-inspired component registryFree software: GNU Affero General Public License v3 or later (AGPLv3+)Installationpip install componentryDocumentationhttps://componentry.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.1 (2018-10-09)First release on PyPI.
Package: composabl
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-cli
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-cli-dev
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-core
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-core-dev
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-dev
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composable-functions
Composable functionsF#-style function composition for Python. Compose functions using bitshift operators>>&<<InstallationTBDUsageYou can wrap anyCallablewithcomposableto make it a composable function. Composable functions can be composed with otherCallableobjects using the bit shift operators (<<&>>):fromcomposable.functionsimportcomposableascdefadd_one(x:int)->int:returnx+1defadd_two(x:int)->int:returnx+2c_add_one=c(add_one)c_add_two=c(add_two)# You can compose with other composables:add_three=c_add_one>>c_add_two# Equivalent to:# add_three = lambda x: add_two(add_one(x))add_three(5)# == 8# Or with any `Callable` objectadd_five=c_add_one>>add_two>>add_two# Equivalent to:# add_five = lambda x: add_two(add_two(add_one(x)))add_five(5)# == 10It also works as a decorator:fromcomposable.functionsimportcomposable@composabledefadd_one(x:int)->int:returnx+1add_three=add_one>>add_one>>add_oneComplex pipelines can be built by reusing simple functions:fromcomposable.functionsimportcomposeimportiofake_streamword_counter=(I>>str.strip>>str.split>>len)word_counter(line)==6You can also compose multiple functions at once withcompose:This can be useful to programatically build complex functions
Package: composable-logs
Composable LogsComposable Logsis a Python library to run ML/data workflows on stateless compute infrastructure (that may be ephemeral or serverless).In particular, using Composable Logs one can do ML experiment tracking without a dedicated tracking server (and database) to record ML metrics, models or artifacts.
Instead, these are emitted using theOpenTelemetry standardfor logging. This is an open standard in software engineering with growing support.It can be useful to think of the logs emitted by Composable Logs as somewhat similar to logs emitted by unit test frameworks (like eg the JUnit format).For example, log events emitted from Composable Logs can be directed to a JSON-file, or sent to any log storage supporting OpenTelemetry (span) events. In either case, this means that one does not need a separate tracking service only for ML experiments.The below shows how a captured JSON log can be converted into a static website based on ML Flow.Composable Logs uses theRay frameworkfor parallel task execution.For more details:Documentation and architecturehttps://composable-logs.github.io/composable-logsLive demoUsing Composable Logs one can run a ML training pipeline using only a free Github account. This uses:Github actions: trigger the ML pipeline daily and for each PR.Build artifacts: to store OpenTelemetry logs of past runs.Github Pages: to host static website for reporting on past runs.The static website is rebuilt after each pipeline run (by extracting relevant data from past OpenTelemetry logs). This uses a fork of MLFlow that can be deployed as a static website,https://github.com/composable-logs/mlflow.Codes for pipeline (MIT):https://github.com/composable-logs/mnist-digits-demo-pipelinePublic roadmap and planninghttps://github.com/orgs/composable-logs/projects/2/views/3Install via PyPILatest releasepip install composable-logshttps://pypi.org/project/composable-logsSnapshot of latest commit to main branchpip install composable-logs-snapshothttps://pypi.org/project/composable-logs-snapshotAny feedback/ideas welcome!License(c) Matias Dahl, MIT, seeLICENSE.md.(Note: As of 1/2023 this project was renamed frompynb-dag-runnertocomposable-logs.)
Package: composable-logs-snapshot
Composable LogsComposable Logsis a Python library to run ML/data workflows on stateless compute infrastructure (that may be ephemeral or serverless).In particular, using Composable Logs one can do ML experiment tracking without a dedicated tracking server (and database) to record ML metrics, models or artifacts.
Instead, these are emitted using theOpenTelemetry standardfor logging. This is an open standard in software engineering with growing support.It can be useful to think of the logs emitted by Composable Logs as somewhat similar to logs emitted by unit test frameworks (like eg the JUnit format).For example, log events emitted from Composable Logs can be directed to a JSON-file, or sent to any log storage supporting OpenTelemetry (span) events. In either case, this means that one does not need a separate tracking service only for ML experiments.The below shows how a captured JSON log can be converted into a static website based on ML Flow.Composable Logs uses theRay frameworkfor parallel task execution.For more details:Documentation and architecturehttps://composable-logs.github.io/composable-logsLive demoUsing Composable Logs one can run a ML training pipeline using only a free Github account. This uses:Github actions: trigger the ML pipeline daily and for each PR.Build artifacts: to store OpenTelemetry logs of past runs.Github Pages: to host static website for reporting on past runs.The static website is rebuilt after each pipeline run (by extracting relevant data from past OpenTelemetry logs). This uses a fork of MLFlow that can be deployed as a static website,https://github.com/composable-logs/mlflow.Codes for pipeline (MIT):https://github.com/composable-logs/mnist-digits-demo-pipelinePublic roadmap and planninghttps://github.com/orgs/composable-logs/projects/2/views/3Install via PyPILatest releasepip install composable-logshttps://pypi.org/project/composable-logsSnapshot of latest commit to main branchpip install composable-logs-snapshothttps://pypi.org/project/composable-logs-snapshotAny feedback/ideas welcome!License(c) Matias Dahl, MIT, seeLICENSE.md.(Note: As of 1/2023 this project was renamed frompynb-dag-runnertocomposable-logs.)
Package: composabl-ray
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-ray-dev
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-train
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: composabl-train-dev
ComposablComposabl helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.Licenses / SeatsComposabl is an enterprise platform and requires an API key to use.We offer 3 types of licenses:Enterprise:for enterprise projects and agent creationsPersonal:for personal usage and testing (typically offered to System Integrators)Trial:validate the Composabl platform (requires sales contact person)One key is needed per user (seat-based licensing)You can request an API Key through the following methods:DiscordMailGetting StartedDownload the Composabl SDK:pip install composablRequest an API KeyGet a simulator or use one of theprebuilt onesCreate an Agent or see ourexamples
Package: compose4py
Compose4pyOnion Model in Python.
Pyton 洋葱模型pip install compose4pyInstallationUsageImportcompose4py:from compose4py import ComposeAll the usual function composition you know and love:def mw_1(ctx, loader_context):
        print("mw_1: %s" % ctx)
        print("mw_1 loader_context: %s" % loader_context)
        ctx += ":mw1"
        # call the next middleware and waiting the new ctx
        ctx = yield ctx
        # use the latest ctx and process more logic
        ctx += ":post_mw1"
        return ctx

    def mw_2(ctx):
        print("mw_2: %s" % ctx)
        ctx += ":mw2"
        ctx = yield ctx
        ctx += ":post_mw2"
        return ctx

    def mw_3(ctx):
        print("mw_3: %s" % ctx)
        ctx += ":mw3"
        return ctx

    compose = Compose(mw_1, mw_2, mw_3, loader_context = {"foo": "bar"})
    result = compose("foo")
    print("final: %s" % result)
    # final: foo:mw1:mw2:mw3:post_mw2:post_mw1Give credits toscrapy开源许可协议Copyright (2018-2020)北京华夏春松科技有限公司Apache License Version 2.0
Package: compose-companion
Compose CompanionThis is a little CLI tool created for my home server.It aims to make it easy to configure and document scripts that should run before and/or after the server containers on docker compose go up or down.Scrips FileThe app will read the scripts from a yaml file in the following format:# compose-companion.yamlx-before-up:sonarr:-echo this will run before sonarr startup-echo this too will run before sonarr startup, after the previous oneradarr:-echo this will run before radarr startup-echo this too will run before radarr startup, after the previous onex-after-up:sonarr:-echo this will run after sonarr startup-echo this too will run after sonarr startup, after the previous oneradarr:-echo this will run after radarr startup-echo this too will run after radarr startup, after the previous onex-before-down:sonarr:-echo this will run before sonarr shutdown-echo this too will run before sonarr shutdown, after the previous oneradarr:-echo this will run before radarr shutdown-echo this too will run before radarr shutdown, after the previous onex-after-down:sonarr:-echo this will run after sonarr shutdown-echo this too will run after sonarr shutdown, after the previous oneradarr:-echo this will run after radarr shutdown-echo this too will run after radarr shutdown, after the previous oneThe container keys should match the ones fromdocker-compose.yamlfile.The app will look for a file namedcompose-companion.yamlon the folder it's first run, if that's not there it'll ask you to inform the file path manually.As the top-level keys start withx-, you can use thedocker-compose.yamlfile itself, if you wish, and these settings will be properly ignored by docker compose.CommandsFor a list of command, runcompose --helpor simplycompose.For details on each command, runcompose [command] --help.
Package: compose_diff
# compose_diffDiff docker-compose files. When deploying using docker-compose, these
files could be used to generate Release Notes. Especially interesting is
to diff two docker-compose Releases by each other, then customers know
the changed components and testers know which part to especially test.UsageVia PythonInstall it via:pip3 install compose_diffAfter that use it likecompose_diff--versionsold.yml new.ymlthis will print the
differences in the used versions/tags between the two compose files.compose_diff--instancesold.yml new.ymlthis will print the amount
of instances of this image between the two compose files.FeaturesSupport for Version 2 and Version 1.Diffs Image VersionsDiffs Image InstancesOutput in Markdown and CSV format
Package: compose-flow
Compose FlowThis utility is built on top ofDocker ComposeandSwarm Mode.  It establishes workflow conventions that are easily shared between team members -- and butlers -- who need to manage and deploy services, including:managingStacksacross multiple Swarms (e.g. separate dev and prod Swarms)connecting to and working with service containersbuilding and publishing imagessharing service configuration between team membersInstallationpip install compose-flowCompose-Flow configurationCreate the file~/.compose/config.ymlwith the following sections.BuildRemotesOptions (for local dev)ex:build:image_prefix:registry.osslabs.netremotes:test:backend:rancherrancher:project:Opscluster:proddev:backend:rancherprod:backend:rancheroptions:local:dirty_working_copy_okay:TrueWith this in place you're ready to go onto your project setup.A basic exampleThis is the most basic file to get started.Place this atcompose/compose-flow.ymlin your project directory:profiles:
  local:
    - docker-compose.ymlAlongside it, place the filecompose/docker-compose.yml:version: '3.7'
services:
  app:
    build: ..
    image: ${DOCKER_IMAGE}For building, run:compose-flow build.For publishing:compose-flow publish.For deploying as configured above:compose-flow -e local deploy.More information atdocs/advanced.md