Saravanan666/pypi-org huggingface dataset:
Package: envo
Define environmental variables in python and activate hot reloaded shells for them.FeaturesInitialisation of variables in a given directory (creates common variables file too)user@pc:/project$ envo local --init  # creates local environment python filesEasy and dynamic handling in .py files (See documentation to learn more)Provides addons like handling virtual environmentsuser@pc:/project$ envo local --init=venv  # will add .venv to PATHAutomatic env variables generation based on defined python variablesHot reload. Activated shell will reload environmental variables when files change.Activating shells for a given environmentuser@pc:/project$ envo local
🐣(project)user@pc:/project$
🐣(project)user@pc:/project$ exit
user@pc:/project$ envo prod
🔥(project)user@pc:/project$Saving variables to a regular .env fileuser@pc:/project$ envo local --savePrinting variables (handy for non interactive CLIs like CI or docker)user@pc:/project$ envo local --dry-runDetects undefined variables.Perfect for switching kubernetes contexts and devops tasksExampleInitialising environmentuser@pc:/project$ envo local --initWill createenv_comm.pyandenv_local.py# env_comm.py@dataclassclassProjectEnvComm(Env):@dataclassclassPython(BaseEnv):version:strclassMeta:raw=["kubeconfig"]# disable namespacingpython:Pythonnumber:intkubeconfig:Path# Add more variables heredef__init__(self)->None:super().__init__(root=Path(os.path.realpath(__file__)).parent)self.name="proj"self.python=self.Python(version="3.8.2")self.kubeconfig=self.root/f"{self.stage}/kubeconfig.yaml"# env_local.py@dataclassclassProjectEnv(ProjectEnvComm):def__init__(self)->None:self.stage="test"self.emoji="🛠️"super().__init__()self.number=12Env=ProjectEnvExample usage:user@pc:/project$ envo  # short for "envo local"
🐣(project)user@pc:/project$ echo $PROJ_PYTHON_VERSION
3.8.2
🐣(project)user@pc:/project$echo $PROJ_NUMBER
12TODO:
Major:
* Refactor start_in
* Add file hooks
* Add bootstrap (versioning etc)
* add error line numberMinor:
* Shell should highlight envo commands on green
* Unnecessary prompt rendered again aftet Ctr-d (only on xonsh?)
* work on public/private fields and methods
* add examples
* print hooks for repr
* Add reload commandBugs:
* exiting while env loading yields Attribute ErrorImprovements:
* type checking ?
Package: envoke
EnvokeEnvoke is a Python package that allows users to create and run keyboard macros with optional delays and randomness. It's designed to be simple yet flexible, providing a straightforward API for automating key presses.InstallationTo install Envoke, run the following command:pipinstallenvokeQuick StartHere's a simple example to get you started:fromenvokeimportenvoke# Create a macro sequencee=envoke()e.enter(interval=0.5).key('a',interval=0.1)# Run the macroe.run(start_delay=3)Advanced UsageEnvoke also supports more advanced features, including continuous macros and random interval differences. See the/examplesdirectory for more use cases.ExamplesBasic Usage# See examples/basic_usage.pyAdvanced Features# See examples/advanced_features.pyUsing Number Keys# See examples/number_keys_example.pyDocumentationWill work on this eventually. For right now/examplesshould suffice.ContributingContributions to Envoke are welcome! I don't currently have aCONTRIBUTING.mdso just submit them freely.PackagingTo package Envoke for distribution, follow these steps:# Ensure you are in the root directory of the projectpython-mbuildAfter the build is successful, you can upload the package to PyPI using twine:python-mtwineuploaddist/*LicenseEnvoke is released under theMIT License.
Package: envolved
EnvolvedEnvolved is a library to make environment variable parsing powerful and effortless.documentation:https://envolved.readthedocs.io/en/latest/fromenvolvedimportenv_var,EnvVar# create an env var with an int valuefoo:EnvVar[int]=env_var('FOO',type=int,default=0)value_of_foo=foo.get()# this method will check for the environment variable FOO, and parse it as an int# we can also have some more complex parsersfromtypingimportList,Optionalfromenvolved.parsersimportCollectionParserfoo=env_var('FOO',type=CollectionParser(',',int))foo.get()# now we will parse the value of FOO as a comma-separated list of ints# we can also use schemas to combine multiple environment variablesfromdataclassesimportdataclass@dataclass# say we want the environment to describe a ConnectionSettingclassConnectionSetting:host:strport:intuser:Optional[str]password:Optional[str]connection_settings:EnvVar[ConnectionSetting]=env_var('service_',type=ConnectionSetting,args={'host':env_var('hostname'),# we now define an env var as an argument. Its suffix will be "hostname", and its type will be inferred from the# type's annotation'port':env_var('port'),'user':env_var('username',type=str),# for most types, we can infer the type from the annotation, though we can# also override it if we want'password':env_var('password',type=str,default=None)# we can also set a default value per arg})service_connection_settings:ConnectionSetting=connection_settings.get()# this will look in 4 environment variables:# host will be extracted from service_hostname# port will be extracted from service_port, then converted to an int# user will be extracted from service_username# password will be extracted from service_password, and will default to None# finally, ConnectionSetting will be called with the parameters
Package: envotate
EnvotateWork in progressSettings management using environment variables and type annotations. This intended to support both class-based and module-based configurations.ExampleDefine a configuration like this:# app/settings.pyfromenvotate.envimportEnv,envfromenvotate.typesimportChoice,Default@envclassDatabase:DB_USER:strDB_PASSWORD:strDB_HOST:strDB_PORT:intDB_NAME:strPY_39="py39"PY_310="py310"@envclassSettings:DATABASE:DatabaseDEBUG:bool=FalsePY_VERSION:Env[str,Choice([PY_39,PY_310]),Default(PY_39)]Then access it in an application:# app/main.pyfromapp.settingsimportSettingsdefmain():print(Settings.DATABASE.DB_NAME)if__name__=="__main__":main()
Package: envoy
Note:Work in progress.This is a convenience wrapper around thesubprocessmodule.You don’t need this.But you want it.UsageRun a command, get the response:>>> r = envoy.run('git config', data='data to pipe in', timeout=2)

>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''Pipe stuff around too:>>> r = envoy.run('uptime | pbcopy')

>>> r.command
'pbcopy'
>>> r.status_code
0

>>> r.history
[<Response 'uptime'>]
Package: envoy_data_plane
envoy_data_planeA conversion of envoyproxy/data-plane-api protocol buffers into Python dataclasses using betterprotoIntended usageThis is a helper library that allows importing every type available in the envoy API.One use-case might be generating Envoy configuration using a Python script.In my case, I will use this library in my custom built control-plane,
so that I have autocompletion in my IDE, and a basic form of validation.In future, this may also help with building an idiomatic GRPC control-plane in Python.InstallationThis package is published to PyPI:python-mpipinstallenvoy_data_planeInstalling specific XDS revisionsThere are branches available with compiled python protobuf files.To install them, you can use the following syntax:pipinstallgit+https://github.com/cetanu/envoy_data_plane@<BRANCHNAME>Examples:pip install git+https://github.com/cetanu/envoy_data_plane@envoy_v1.13.7
pip install git+https://github.com/cetanu/envoy_data_plane@envoy_v1.16.2
pip install git+https://github.com/cetanu/envoy_data_plane@envoy_v1.17.2
pip install git+https://github.com/cetanu/envoy_data_plane@envoy_v1.18.2
pip install git+https://github.com/cetanu/envoy_data_plane@envoy_v1.19.0Not all versions may be available. Raise an issue if you need another one added.Exampleimportstringcaseimportjsonimportenvoy_data_plane.envoy.api.v2asenvoyroute_config=envoy.RouteConfiguration(name='MyRouteConfig',virtual_hosts=[envoy.route.VirtualHost(name='SomeWebsite',domains=['foobar.com'],routes=[envoy.route.Route(name='catchall',match=envoy.route.RouteMatch(prefix='/'),direct_response=envoy.route.DirectResponseAction(status=200,body=envoy.core.DataSource(inline_string='Hello there')))])])response=envoy.DiscoveryResponse(version_info='0',resources=[route_config],)print(json.dumps(response.to_dict(casing=stringcase.snakecase),indent=2))Result:{
  "version_info": "0",
  "resources": [
    {
      "name": "MyRouteConfig",
      "virtual_hosts": [
        {
          "name": "SomeWebsite",
          "domains": [
            "foobar.com"
          ],
          "routes": [
            {
              "name": "catchall",
              "match": {
                "prefix": "/",
                "headers": [],
                "query_parameters": []
              },
              "direct_response": {
                "status": 200,
                "body": {
                  "inline_string": "Hello there"
                }
              },
              "request_headers_to_add": [],
              "response_headers_to_add": []
            }
          ],
          "virtual_clusters": [],
          "rate_limits": [],
          "request_headers_to_add": [],
          "response_headers_to_add": []
        }
      ],
      "response_headers_to_add": [],
      "request_headers_to_add": []
    }
  ]
}
Package: envoy-protobuf-builder
envoy-proto-builderBuilds and installs Envoy protocol buffers and the following
dependencies:data-plane-apigoogleapisprotoc-gen-validateopencensus-protoHow it worksClones the Envoy repository and associated dependencies to a temporary
location. Builds the proto files into virtual Python module and installs
the module with pip. The protobuf files are available inenvoy_proto.Installationpip installl envoy-proto-builderUsageRunning with no arguments will install the Envoy files from the master branch.usage: envoy-protobuf-builder [-h] [--version VERSION] [--src-dir SRC_DIR] [--no-clone]

optional arguments:
  -h, --help         show this help message and exit
  --version VERSION  The Envoy version to build. Defaults to master.
  --src-dir SRC_DIR  The directory to clone the repositories to. If not specified a temporary
                     location is used.
  --no-clone         Build the files with cloning the repositories.Code Samplefrom.commonimportmake_anyfromenvoy_proto.envoy.config.filter.accesslog.v2.accesslog_pb2importAccessLogfromenvoy_proto.envoy.config.accesslog.v2.file_pb2importFileAccessLogfromenvoy_proto.envoy.api.v2.core.config_source_pb2importConfigSourcefromenvoy_proto.envoy.api.v2.listener.listener_pb2import(Filter,FilterChain,)fromenvoy_proto.envoy.config.filter.network.http_connection_manager.v2.http_connection_manager_pb2import(HttpConnectionManager,HttpFilter,Rds,)FilterChain(filters=[Filter(name='envoy.http_connection_manager',typed_config=make_any(HttpConnectionManager(stat_prefix='ingress_http',rds=Rds(route_config_name='local_route',config_source=ConfigSource(path='/etc/envoy/routes.yaml',)),http_filters=[HttpFilter(name='envoy.router')],access_log=[AccessLog(name='envoy.file_access_log',typed_config=make_any(FileAccessLog(format='''\%REQ(:METHOD)% %REQ(:AUTHORITY)%%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% -> %UPSTREAM_CLUSTER% %REQ(:PATH)% %RESPONSE_CODE% %RESPONSE_FLAGS%\n''',path='/dev/stdout',)))])))])History0.1.0 (2019-12-05)First release on PyPI.
Package: envoy-reader
A program to read from an Enphase Envoy on the local network. Reads electricity production and consumption (if available) for the current moment, current day, the last seven days, and the lifetime of the Envoy.
Also reads production from individual inverters if supported.Tested on the original Envoy (production data only) and the Envoy S (production and consumption data).This reader uses a JSON endpoint on the Envoy gateway:Original Envoy:http://envoy/api/v1/production(available on software level R3.9 and later)Envoy S:http://envoy/production.jsonFor older Envoy with software before R3.9, data is collected from html athttp://envoy/productionKnown issuesEnvoy firmware D7.x.x and above are not supported right now due to authentication method changed by Enphase.
Package: envoyUtils
EnphaseEnergyVarious collected information about Enphase Energy solar system (I am just starting on this one… But the installer password was highly requested on the web, so I am starting with that one)passwordCalc.py- sample code to calculate the installer password for a given serial numberfindEnphaseWithBonjour.py- sample code to find Enphase Envoy via Bonjour/Zeroconf. This also provides the serial number of the Envoy.enphaseStreamMeter.py- sample code to stream production/consumption. Requires the installer password.
Package: envoy-utils
EnphaseEnergyVarious collected information about Enphase Energy solar system (I am just starting on this one… But the installer password was highly requested on the web, so I am starting with that one)passwordCalc.py- sample code to calculate the installer password for a given serial numberfindEnphaseWithBonjour.py- sample code to find Enphase Envoy via Bonjour/Zeroconf. This also provides the serial number of the Envoy.enphaseStreamMeter.py- sample code to stream production/consumption. Requires the installer password.
Package: envoy-webhook-auth-decorator
Envoy webhook authentication decoratorInstallationFrom source code:python setup.py installFrom pypi:pip install envoy-webhook-auth-decoratorUsageimport envoy_webhook_auth_decorator

@envoy_webhook_auth_decorator.authentication({"api_key": ..., "timestamp": ..., "token": ..., "signature": ...})
def mytest():
    print("Testing...")

if __name__ == '__main__':
    mytest()LicenseThis software is licensed under theMIT licenseSeeLicense fileChangelog0.1.1Update version0.1.0Add coverage0.0.3Remove hmac_signature upper process logic0.0.2Support Envoy webhook callback authentication0.0.1Initial public release
Package: envparse-stubs
Type stubs for envparseThis package adds type annotations for theenvparselibrary.Known IssuesTheforceandpreprocessorparameters have been omitted.Adefaultvalue ofNoneis not allowed forlist(),set(),tuple()ordict(). Instead, use an empty list/set/tuple/dict
as the default.A schema cannot be provided toEnv.__init__(), as this would make it impossible to infer the return types of other methods.AuthorRob Percival
Package: envpath
EnvpathEnvpath is a command line utility for saving and retrieving your development environments and paths.FeaturesSave your development environment and pathOpen saved environments and their paths from any directoryUsageThere are currently only two commands available.1) Saving an envIf you want to save a virtual environment, make sure you are in the working directory of that project and run the following command (replaceenvnamewith the name of your environment):envpath --save envnameYou can use-sinstead of--save2) Opening an envTo open a previously saved environment, just run the following command from any directory or path (replaceenvnamewith the name of your environment):envpath --open envnameHere too, you can also use-oinstead of--openRequirements & DependenciesThis package depends on the following python packages and will install them if you don't already have them installed:virtualenv- Virtual Python Environment builderArgparse- Already included in the python standard library from python >= 3.2Just like these packages, Envpath is also open source software.DevelopmentWant to contribute code to this repo? You are welcome to do so.Contact the AuthorReach me via:
Email -Click to send mailTwitter@untamedthinkingLicenseMIT
Package: env-paths
env-pathsThis package is a modifiedsindresorhus/env-paths from nodejsfor python.Returns the directory where the cache is located. This is different for each os.Install$ pip install env-pathsUsagefromenv_pathsimportenv_pathspaths=env_paths('MyApp')paths.data# => '/home/atu4403/.local/share/MyApp-python'paths.config# => '/home/atu4403/.config/MyApp-python'Relatedsindresorhus/env-paths: Get paths for storing things like data, config, cache, etcLicenseMIT ©atu4403
Package: env-permissions-manager
Permissions ManagerOverviewPermissions Manager is a Python package that allows you to manage the permissions of your Python environments. It provides a simple and efficient way to check, change, and report the permissions of multiple Python packages.InstallationYou can install the Permissions Manager package using pip:pipinstallpermissions-managerFeaturesCheck Permissions: Check the read and write permissions of multiple Python packages.Change Permissions: Change the permissions of multiple Python packages.Report Non-Standard Permissions: Provide a report of multiple Python packages with non-standard permissions.UsageHere’s a basic usage example of Permissions Manager:frompermissions_manager.permissions_managerimportPermissionsManagerpermissions_manager=PermissionsManager()package_names=['requests','numpy']permissions=permissions_manager.check_permissions(package_names)print(permissions)new_permissions=0o755
permissions_manager.change_permissions(package_names,new_permissions)standard_permissions=Truenon_standard_packages=permissions_manager.report_non_standard_permissions(package_names,standard_permissions)print(non_standard_packages)Sample output of the aboveCurrentPermissions:{'requests':True,'numpy':True}Non-StandardPackages:[]If the list is empty ([]), it means all specified packages have permissions matching the specified standard (True). No non-standard packages are found.If the list contains elements, it means there are packages with permissions not matching the specified standard. Each element in the list will indicate a package and its current permissions.TestsThis package includes a suite of tests to ensure its functionality. You can run these tests using pytest:pytestBenefitsPermissions Manager provides a simple and efficient way to manage the permissions of your Python environments. This can be particularly useful in shared environments, where multiple users may need different levels of access to certain packages.LicenseThis project is licensed under the terms of the MIT license.ContactIf you have any questions or feedback, please feel free to contact the author atkarimbaidar@gmail.com.
Package: envppp
envppCli para criar projetos em Python, Javascript e C++ que pode ser criada em qualquer ambiente.Facilita a criação projetos em C++, Python em JavascriptMultiplataformaCompletamente em PT-BRSumárioDuvidas sobre JavascriptDuvidas Sobre C++Duvidas sobre PythonFAQPor que não continuar a versão em Javascript?Gostei e queria testar o typer, então decidi refazer o projeto em Python adicionando outras linguagens que uso no dia a dia.Posso usar no Linux?Sim, pode usar no Windows e em sistemas em UNIX.Se eu excluir ou editar os diretórios, eu quebro alguma coisa?Não, você pode remover e adicionar coisas tranquilamente. A cli apenas cria os projetos e em alguns casos ele só automatiza processos manuais.Quero contribuir pro projeto!Abra uma issue ou uma pull request. :)Objetivos:Dar suporte a Javascript/Typescript.Dar suporte a C++.Usar docker para fazer o ambiente ser reproduzível em qualquer lugar.Criar documentação para os comandos.Concluir fase de testes no ambiente Linux.Criar documentação geral para o projeto.
Package: env-proxy
EnvProxyEnvProxyprovides a class used to query environmental variables with typehinting a conversion to basic Python types.
You can query your environment easily and keep your typehinting.InstallationUsingpip:pip install env-proxyUsingpoetry:poetry add env-proxyExample# Import EnvProxyfromenv_proxyimportEnvProxy# Basic examples## Environment variable "DATABASE_HOST"database_host=EnvProxy.get_str("database-host")## If you want the function to fail if the value does not exist, use methods with `_strict` suffixdatabase_nonsene=EnvProxy.get_str_strict("database-nonsense")### ValueError: No value for key DATABASE_NONSENSE in environment## Specify default for the (non-zero) variable "DATABASE_PORT"database_port=EnvProxy.get_int("database-port")or5432# Specify custom prefixclassMyProxy(EnvProxy):env_prefix:Optional[str]="MYAPP"## Now all variables are expected to be prefixed with MYAPP_database_host=EnvProxy.get_str("database-host")### Searches for MYAPP_DATABASE_HOST variableDocumentationSeedocs
Package: envpy
OverviewPython library for loading config from environment variables. Suitable
for implementing the config requirements of a 12-factor app:https://12factor.net/configGetting StartedInstallationTo install use pip:$> pip install envpyRequirements before installation:python3pip3Usage"""Basic usage script for envpy"""importenvpyCONFIG=envpy.get_config({# This will raise an error if it cannot be found in the environment# because no default has been set.'SECRET_KEY':envpy.Schema(value_type=str),# This has a default value and as such won't raise an error if it cannot# be found in the environment. However, the value type is set to 'int'# which means that an error will be raised if a value is present in the# environment but cannot be parsed as an integer.'NUM_WORKERS':envpy.Schema(value_type=int,default=4),})if__name__=='__main__':print('Secret Key:',config['SECRET_KEY'])print('Number of workers:',config['NUM_WORKERS'])Value TypesstrNo parsing is applied and the string is returned directly from the
environment.intThe value will be parsed as an integer. Must match:  ^[0-9]+$.floatThe value will be parsed as a float. Must match:  ^[0-9]+.[0-9]+$.boolThe value will be parsed as a boolean. Must be one of the following:“1” (True)“0” (False)“true” (True, case insensitive)“false” (False, case insensitive)DevelopmentInstallationThis project makes use of virtual environments to provision your
development environment. Once the following requirements have been met
further installation is managed automatically by the Makefile.Requirements before provisioning:python3pip3virtualenvmakeUsageThe following commands will create a virtual environment (if not already
present) for the application and will install the necessary dependencies
there before running the requested command.Run the package:$> makeRun the unit tests:$> make testRun the linter:$> make lintRebuild your virtual environment:$> make rebuild_venv
Package: env.py
env.py======Easily manage your python application settings for different environmentsUsage:------Consider following file structure somewhere in your python application:```- app- settings.py- local_env.py            # required by env.py- local_settings.py- dev_settings.py- prod_settings.py- prodstage_settings.py- test_settings.py```What `env.py` does is, it allows you to define different environment custom settingsinside files named `$env_settings.py`. Then, inside `local_env.py` definecurrent environment like `ENV='prod'`.At the top or at the bottom of `settings.py` based upon how you use `env.py`, use as:`from env import *`This will configure your application for your current `ENV` custom settings along with common `settings.py`