Saravanan666/pypi-org huggingface dataset:
Package: eco-parser
ECO ParserParse ward lists from Electoral Change Orders onhttp://www.legislation.gov.uk/What does this package do?This package solves a very specific problem.Local Government electoral divisions/wards in the UK are defined by a piece of legislation called an Electoral Change Order. An Electoral Change Order (ECO) always comes into force the day before the first election which is held using the boundaries it defines. Once this first election has happened, details of the new divisions are fairly easy to get hold of. They are published as machine-readable structured data by organisations likeOrdnance Surveyand theOffice for National Statistics. If you need information about divisions that have already been used for one or more elections, use one of these sources. In that situation, this tool is probably the least useful route to the information you want.In the case where we need to talk about local electoral divisions which have been defined by an ECO but which have not yet been used in an election (i.e: the ECO has been made, but has not yet come into force), the only source for the division names is the ECO legislation itself.This package provides some routines to help with parsing ward and division names from thelegislation.gov.uk'sXML APIoutputs (which are semi-structured). It is early days, so there are probably going to be some formats we don't support yet. If you find one in new or recent legislation,raise an issue.TL;DRIf you need the official names of electoral divisions that are already in use, get the data fromOS Boundary Line,ONS Geographyor a web service likemapit. This information is already published as convenient machine-readable structured data.If you need the official names of electoral divisions that are not in use yet, this package can help you parse them from legislation.Installationpipinstalleco-parserUsageOn the consoleeco_parser"http://www.legislation.gov.uk/uksi/2017/1067/schedule/1/made/data.xml">out.csvAs a libraryfromeco_parserimportEcoParser,ParseErrorp=EcoParser("http://www.legislation.gov.uk/uksi/2017/1067/schedule/1/made/data.xml")try:result=p.parse()exceptParseError:raiseLicensingTheeco-parsersoftware is made available under the MIT License.Data Parsed from legislation.gov.uk is covered by theOpen Government Licence v3. Your use of the data should comply with it.DevelopmentRun the tests locally:./run_tests.pyBuild package locally:./build.sh
Package: ecope
Ecommerce Perú Scrap CLII'm already tired of the GUIsExtract a list of products from some e-commerce websites more popular of PerúFeaturesScraping ecommerces by product category (Only some categories)Products export data in csv or jsonProductionBefore you need Python 3.7 or more, then install ecope with pippip install ecopeThen you can usage this commandecopeCLI :)Example 1: Export laptops in CSV formatecope -c laptop -f csvExample 2: Export celular in JSON format with filename export.jsonecope -c celular -f json -o exportFor more infoecope -hDevelopmentLocal installingFirst go toapplicationfolder and install (Python3.7 o later) with virtualenv or pipenvvirtualenv env -p python3Then install dependencies:pip install -r requirements.txtFor data scraping use CLI more info:python cli.py -hTodosAdd more ecommerces websitespaginate supportSupport dockerTestsCollaborateHow to collaborate?Let me issues orAdd more items inapplication/ecommerces.json(You can with PR direct)LicenseMIT
Package: ecophylo
EcoPhyloEcophylois dedicated to coalescent-based simulation of eco-evolutionary dynamics. Species assemblages and their shared ancestry can be simulated by jointly taking into account the influence of past demographic fluctuations and extinctions along with how divergent genotypes have introduced new species over time through speciation.The source for this project is availablehere.DependenciesThis package depend onpython 3.7.There are multiple dependencies to other python packages. This will be done when installing ecophylo tool in most cases.You can experiment difficulties for installing msprime, check the helphereInstall (with pip)To install this package, you can either download the tar.gz file in thedistdirectory of the repository :python3-mpipinstall<path_to>/ecophylo-<VERSION>.tar.gzor install from the Python Package index (Pypi) :python3-mpipinstallecophyloor install from github (it does not work for private repository):python3-mpipinstallgit+https://github.com/thegreatlizzyator/ecophylo/tree/packaging/dist/ecophylo-0.0.5.tar.gzUsageYou can simulate trees using this package main function in python.importecophylon=25#the number of sampled individualscom_size=[[5000,10000,50000]]# the size of the assemblage in the past, the first element is the current assemblage sizemu=0.001# the point mutation ratechangetime=[[0,700,10000]]# the dates (in generation time) at which the assemblage has changed sizes in the pasttree=ecophylo.simulate(samples=n,com_size=com_size,mu=mu,changetime=changetime,seed=42)print(tree)Maintainers@thegreatlizzyator&@gowachin.ContributingFeel free to dive in!Open an issueor submit PRs.thegreatlizzyator follows theContributor CovenantCode of Conduct.ContributorsThis project exists thanks to all the people who contribute.LicenseCeCILL-B© Elizabeth Bathelemy
Package: ecoport
conda-exportRefine of conda env export --from-history.
Now you can export environment with version using --from-history option.
You can choose which package should not appear in the environment.yaml file by CLI and a .yaml file.Sample OutputOutput ofconda env export --from-historywith version number.name:torchchannels:-pytorch-defaultsdependencies:-isort=5.9.3-python=3.10.6-pytorch=1.13.0-torchaudio=0.13.0-torchvision=0.14.0Usagepython-mecoport-ftmp.yaml# Save env to ./tmp.yamlpython-mecoport# Save env to ./environment.yamlpython-mecoport--exclusionsisort# Excludes isortpython-mecoport--configtest/config.yaml# Using config option (current only option for exclusion). --exclusion has higher priority.python-mecoport--no-prefix# eliminate the prefix entrySample config file (test/config.yaml):exclusions:-black-isort
Package: ecopy
EcoPy: Python for Ecological Data Analyses******************************************.. image:: https://zenodo.org/badge/17555/Auerilas/ecopy.svg:target: https://zenodo.org/badge/latestdoi/17555/Auerilas/ecopy**EcoPy** provides tools for ecological data analyses. In general, it focuses on multivariate data analysis, which can be useful in any field, but with particular attention to those methods widely used in ecology. `The homepage, with full documentation and examples, can be found here <http://ecopy.readthedocs.io>`_Install via 'pip install ecopy'What's New=======0.1.2.2--------- More Python 3.x compatibility- Fix typos in code and examples on readthedocs. Thorough code checkLicense=====**EcoPy** is distributed under the MIT licenseVersion=====0.1.2.2Examples======Transforming a site x species matrix, dividing by site totals::import ecopy as epvarespec = ep.load_data('varespec')newMat = ep.transform(varespec, method='total', axis=1)Calculating Bray-Curtis dissimilarities on the new matrix::brayMat = ep.distance(newMat, method='bray')PCA on US Arrests data::USArrests = ep.load_data('USArrests')prcomp = ep.pca(USArrests, scale = True)prcomp.biplot(type = 'distance')prcomp.biplot(type = 'correlation')Full online documentation is a work in progressTO-DO====- MINIMUM SPANNING TREE- PROCRUSTES ROTATION- LINEAR/SURFACE ENVIRONMENTAL FITTING- MAXENT WRAPPER- MANY MANY OTHER THINGS
Package: ecoscape-connectivity
EcoScape Connectivity ComputationThis package implements the computation of connectivity and flow according
to the EcoScape algorithm.AuthorsLuca de Alfaro (luca@ucsc.edu)Natalia Ocampo-Peñuela (nocampop@ucsc.edu)Coen Adler (ctadler@ucsc.edu)Artie Nazarov (anazarov@ucsc.edu)Natalie Valett (nvalett@ucsc.edu)Jasmine Tai (cjtai@ucsc.edu)Project home pageUsageThe package can be used both from the command line, and as a python module.
For command line options, do:ecoscape-connectivity --helpAs a Python module, the main function iscompute_connectivity:fromecoscape_connectivityimportcompute_connectivitydefcompute_connectivity(habitat_fn=None,terrain_fn=None,connectivity_fn=None,flow_fn=None,permeability_dict=None,gap_crossing=2,num_gaps=10,num_simulations=400,seed_density=4,single_tile=False,tile_size=1000,tile_border=256,minimum_habitat=1e-4)The computation will be much faster if you run it with GPU support.The output connectivity and flow are encoded in the output geotiffs as follows:For connectivity, the values from [0, 1] are linearly rescaled to the range 0..255 and encoded as integers, so that 0 corresponds to no connectivity, and 255 to maximum connectivity.For flow, the values of $f \in [0, \infty)$ are encoded in log-scale via
$20 \cdot log_{10} (1 + f)$ (so that the flow is expressed in dB, like
sound intensity), and clipped to integers in the 0..255 range.Arguments:habitat_fn: name of habitat geotiff. This file must contain 0 = non habitat,
and 1 = habitat.terrain_fn: name of the landscape matrix geotiff.  This file contains terrain categories that are
translated via permeability_dict.connectivity_fn: output file name for connectivity.flow_fn: output file name for flow.  If None, the flow is not computed, and the
computation is faster.permeability_dict: Permeability dictionary.  Gives the permeability of each
terrain type, translating from the terrain codes, to the permeability in [0, 1].
If a terrain type is not found in the dictionary, it is assumed it has permeability 0.gap_crossing: size of gap crossing in pixels.num_gaps: number of gaps that can be crossed during dispersal.num_simulations: Number of simulations that are done.seed_density: density of seeds.  There are this many seeds for every square with edge of
dispersal distance.single_tile: if True, instead of iterating over small tiles, tries to read the input as a
single large tile.  This is faster, but might not fit into memory.tile_size: size of (square) tile in pixels.tile_border: size of tile border in pixels.minimum_habitat: if a tile has a fraction of habitat smaller than this, it is skipped.
This saves time in countries where the habitat is only on a small portion.Example NotebooksHere you can find aColab Notebookthat
demonstrates connectivity computation.
Package: ecoscape-utilities
EcoScape UtilitiesThis package is simply a collection of utilities that are useful for running
Colab notebooks and other code.These are not packages distributed with pip.  To install on Colab, simply do:!pip install git+https://github.com/ecoscape-earth/ecoscape-utilities.gitAuthorsLuca de Alfaro (luca@ucsc.edu)Natalia Ocampo-Peñuela (nocampop@ucsc.edu)Coen Adler (ctadler@ucsc.edu)Artie Nazarov (anazarov@ucsc.edu)Natalie Valett (nvalett@ucsc.edu)Jasmine Tai (cjtai@ucsc.edu)
Package: ecoscope
EcoscopeEcoscope is an open-source analysis module for tracking, environmental and conservation data analyses. It provides methods and approaches for: Data I/O (EarthRanger, Google Earth Engine, Landscape Dynamics, MoveBank, Geopandas), Movement Data (Relocations, Trajectories, Home-Ranges, EcoGraph, Recurse, Geofencing, Immobility, Moving Windows, Resampling, Filtering), Visualization (EcoMap, EcoPlot), Environmental analyses (Seasons determination, Remote sensing anomalies), Covariate labeling (Day/Night, Seasonal, GEE Image Collections/Images).Development & TestingDevelopment dependencies are included inenvironment.yml. You will also need to configure the selenium driver following these instructions (note that this is not needed if running ecoscope within Google Colab as selenium is already configured):https://www.selenium.dev/documentation/webdriver/getting_started/install_drivers/Please configure code-quality git hooks with:>>> pre-commit installCopyright & LicenseEcoscope is licensed under BSD 3-Clause license. Copyright (c) 2022, wildlife-dynamics.DonateEcoscope is currently developed and maintained by the Mara Elephant Project (www.maraelephantproject.org) a not-for-profit elephant conservation organization located in the Masai Mara, Kenya. If you find Ecoscope useful in your work, please consider donating to help support ongoing development and maintenance of the project or the conservation work performed by MEP:https://maraelephantproject.org/donate/AcknowledgmentsWe thank the many individuals and organizations who have contributed to the development of Ecoscope: Jake Wall, Peter Kulits, Zakaria Hussein, Catherine Villeneuve, Jes Lefcourt, Chris Jones, George Wittemyer, Mara Elephant Project, Allen Institute for Artificial Intelligence, Google Earth Outreach, Save the Elephants, Elephants Alive, Berkeley Data Science Society.
Package: ecosizer-engine
EcosizerEngineRequirements:This software requires a python version greater than or equal to 3.11 to be installed in the environment it is running in.Using the package in scripts:Install the package with pip$ pip install ecosizer-engineTo import and use the tools in this package, add the following import statement to your script:from ecosizer_engine_package import *You should now be able to use the features of EcosizerEngine in your scriptRunning locally in a container:First, clone the EcosizerEngine repo from github$ git clone https://github.com/EcotopeResearch/EcosizerEngine.gitDepending on what type of environment you want to run the code in, please follow the appropriate steps.Steps for installing in a virtual environment:Navigate to the EcosizerEngine directory. This should be the same directory level as src/, setup.py, and this README document.Run the following command:$ pip install -e .This will install the ecosizer-engine package locally in editable format, such that changes you make in the source code here will be reflected in implementation.
This pip install should also install all dependencies for ecosizer-engine (i.e. numpy, scipy, pytest, and plotly)Steps for installing using docker container:Navigate to the EcosizerEngine directory.Build container with docker file$ docker build -t ecosizerengine:latest .Run docker container$  docker run -it ecosizerengine bashWhen you are done messing about in the docker image, just type the command$ exitor press ctrl+c then ctrl+dSteps for installing conda environment from the Anaconda prompt:Navigate to the EcosizerEngine directory.Create new environment from .yml file.$ conda env create --file EcosizerEngine.ymlIf the environment creation doesn't work, make sure Anaconda is up-to-date with$ conda update --allIf that doesn't work, you may need to force Anaconda to download and use python 3.11 (it defaults to 3.9) by making another environment$ conda create -n py311 python=3.11
$ conda activate py311
$ conda env create --file EcosizerEngine.ymlCheck that the environment was created$ conda env listActivate the new environment$ conda activate EcosizerEngineIf an environment already exits it can be removed with:$ conda remove --name EcosizerEngine --allAll the available environment can be found with:$ conda env listTesting:From the parent directory, type$ python -m pytestThis will run all unit tests for the packageUpdating Documentation:If not installed in environment: pip install sphinx and numpydocsnavigate to docs directory and run:$ make htmlContact InformationTo get in touch with Ecotope Inc. go here:http://ecotope.com/contact/
Package: ecosound
Welcome to ecosound!Ecosoundis an open source python package to facilitate the analysis of passive acoustic data. It includes modules for manual annotation
processing and visualization, automatic detection, signal classification, and localization. It heavily relies on libraries such as xarray,
pandas, numpy and scikit-learn. Under the hood it also uses dask which supports the processing of large data sets that donâ€™t fit into memory,
and makes processing scalable through distributed computing (on either local clusters or on the cloud). Outputs from ecosound are compatible
with popular bioacoustics software such asRavenandPAMlab.StatusEcosound is very much a work in progress and is still under heavy development.
At this stage, it is recommended to contact the main contributor before using
ecosound for your projects.DocumentationNo documentation yet, but we’re working on it…https://ecosound.readthedocs.ioContributorsXavier Mouy(@XavierMouy) leads this project as part of his PhD in theJuanes Labat the University of Victoria (British Columbia, Canada).CreditsThis project was initiated in theJuanes Labat the University of Victoria (British Columbia, Canada) and received funding from theCanadian Healthy Oceans NetworkandFisheries and Oceans Canada - Pacific Region.LicenseEcosound is licensed under the open sourceBSD-3-Clause License.History0.0.0 (2020-11-20)First release on PyPI.
Package: ecosystem-notebooks
What is Ecosystem Notebooks?Ecosystem Notebooks is a wrapper for the Ecosystem API servers. They can
be used for both the Prediction and Runtime servers.The notebooks are a great interface to work from in order to test, and
explore the server’s capabilities. They allow you to navigate them
easily by removing the complexities of directly interacting with the
APIs.Ecosystem Notebooks are built using the Jupyter Notebook coding
environment, and Python 3 kernel for code execution.RequirementsTo use any of the notebooks, access to an Ecosystem API server is
requiredJupyter NotebookPython 3: The notebooks were
built using python 3.6, but most Python 3 versions will workGetting startedTo begin using Ecosystem Notebooks, you need to first install Jupyter
Notebook.This can be done by running the configure_jupyter.sh shell script. In
addition, recommended styling options can be added by running the
configure_jupyter_styling.sh shell script. While this is not required,
you are welcome to play around with it to personalise the Ecosystem
workbench style.To install the relevant python code, add the parent directory
(ecosystem-notebooks) to the PYTHONPATH environment variable.Once Jupyter is installed, enter the directory containing the notebooks.
At the designated .ipynb extension, run the command:jupyternotebookThis will open up a default web browser to the Jupyter Notebook landing
page from which you can open up one of the desired notebooks.Jupyter Landing PageHow does Ecosystem Notebooks workFrom within a chosen notebook, Ecosystem Notebooks can be used. This
coding environment, from which you can edit and run live code, provides
the interface with which to utilise the API endpoints for Ecosystem
Prediction and Runtime servers.For easy navigation within any of the
notebooks, you can use the table of contents which will be situated on
the left.In order for the API endpoints to properly function, you will need to
login. Depending on which notebooks you have chosen to use, logging in
could require a URL endpoint. Or a username, password and URL
combination, which will generate an authentication token. This token
will activate the API, then you can begin using Ecosystem Notebooks!LoginEcosystem Notebooks contains all the available API endpoints on the
Ecosystem Servers. You can either play around in the ecosystem
environment, or you can use it in your own chosen infrastructure.
Package: ecotricity-client
Ecotricity ClientThis python library is intended to be used against the Ecotricity API used on thecustomer portalfor fetching meter readings.Example usage:from ecotricity.client.requests import AgreementsRequest, ReadsRequest, AccountsRequest

from ecotricity.client.service import open_session

user = "yourUser"
password = "yourPassword"

session = open_session(user, password)

accounts_req = AccountsRequest()
accounts_res = accounts_req.get_accounts(session)
for account in accounts_res.data.results:
    agreements_req = AgreementsRequest()
    agreements_res = agreements_req.get_agreements(session, account.id,)
    for agreement in agreements_res.data.results:
        for product in agreement.products:
            for meter_point in product.meter_points:
                fuel_type = meter_point.fuel_type
                meter_id = meter_point.industry_id
                meter_reads_req = ReadsRequest()
                meter_reads_res = meter_reads_req.get_reads(session, meter_point.industry_id)
                for readings in meter_reads_res.data.results:
                    for reading in readings:
                        register_id = reading.register_industry_id
                        print(f'{fuel_type} - {meter_id} - {register_id} - {reading.date} - {reading.value}')
Package: ecourbissp
Eco Urbis SPAuthor: Julio BlancoVersion: 0.0.1DescriptionCode to get a simple dictionary with lines and statues from the Official web of Eco Urbis in São PauloLicenseCopyright 2019  Julio Manuel Blanco PérezPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: ecowater-softener
Ecowater Softenerecowater-softener is a Python library for collecting information from Ecowater water softeners.InstallationUse the package managerpipto install ecowater.pipinstallecowater-softenerUsagefromecowater_softenerimportEcowaterecowaterDevice=Ecowater('username','password','serialnumber')# returns 'all data other commands can get' as a dictionaryecowaterDevice.getData()# returns 'days until the device is out of salt' as an integerecowaterDevice.daysUntilOutOfSalt()# returns 'date when device will run out of salt' as datetime objectecowaterDevice.outOfSaltOn()# returns 'the salt level' as an integerecowaterDevice.saltLevel()# returns 'the salt level in percent' as an integerecowaterDevice.saltLevelPercent()# returns 'the amount of water used today' as an integerecowaterDevice.waterUsageToday()# returns 'the average amount of water used daily' as an integerecowaterDevice.waterUsageDailyAverage()# returns 'the amount of water available' as an integerecowaterDevice.waterAvailable()# returns 'the amount of water flow' as an integerecowaterDevice.waterFlow()# returns 'the units for the water measurements' as a stringecowaterDevice.waterUnits()# returns 'true or false depending on whether recharge is enabled'ecowaterDevice.rechargeEnabled()# returns 'true or false depending on whether there is a recharge scheduled'ecowaterDevice.rechargeScheduled()# returns 'true or false depending on whether the device is online'ecowaterDevice.deviceStatus()UsingecowaterDevice.getData()is optimal as it only uses one request and returns all of the data as a dictionary.E.g.{'daysUntilOutOfSalt': 421, 'outOfSaltOn': datetime.datetime(2025, 5, 5, 0, 0), 'saltLevel': 3, 'saltLevelPercent': 21, 'waterUsageToday': 50, 'waterUsageDailyAverage': 143, 'waterAvailable': 1332, 'waterFlow': 0, 'waterUnits': 'Liters', 'rechargeEnabled': True, 'rechargeScheduled': False, 'deviceStatus': True}CreditsThanks toKyle Johnsonfor his work on using python to interface with Ecowater water softeners. Most of this libraries code is built upon code which he wrote. You can read his article regarding scraping data from Ecowater water softeners athttps://gnulnx.net/2020/02/18/ecowater-api-scraping/ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT