code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
{{ fullname | escape | underline }}
.. automodule:: {{ fullname }}
{% block functions %}
{% if functions %}
.. rubric:: Functions
.. autosummary::
:toctree: {{ objname }}
{% for item in functions %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block classes %}
{% if classes %}
.. rubric:: Classes
.. autosummary::
:toctree: {{ objname }}
:template: class.rst
{% for item in classes %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
{% block exceptions %}
{% if exceptions %}
.. rubric:: Exceptions
.. autosummary::
{% for item in exceptions %}
{{ item }}
{%- endfor %}
{% endif %}
{% endblock %}
| 21cmFAST | /21cmFAST-3.3.1.tar.gz/21cmFAST-3.3.1/docs/templates/module.rst | module.rst |
```
%matplotlib inline
import matplotlib.pyplot as plt
from py21cmmc import run_lightcone
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import py21cmmc as p21
from powerbox import get_power
init, perturb, xHI, Tb = p21.run_coeval(
redshift= 8.0,
user_params = dict(
HII_DIM = 100,
BOX_LEN = 300.0
)
)
plt.imshow(init.lowres_density[:,:,0], extent=(0,300,0,300));
plt.imshow(Tb.brightness_temp[:,:,0], extent=(0,300,0,300))
p, k = get_power(Tb.brightness_temp, boxlength=Tb.user_params.BOX_LEN)
plt.plot(k,p*k**3)
plt.xscale('log')
plt.yscale('log')
lc = run_lightcone(6.5, max_redshift=12.0, user_params={"HII_DIM":100, "DIM":300})
plt.figure(figsize=(10,4))
plt.imshow(lc.brightness_temp[0], origin='lower')
plt.colorbar()
```
| 21cmFAST | /21cmFAST-3.3.1.tar.gz/21cmFAST-3.3.1/devel/visualise_boxes_and_power.ipynb | visualise_boxes_and_power.ipynb |
import matplotlib.pyplot as plt
import numpy as np
from py21cmfast import AstroParams, CosmoParams, FlagOptions, UserParams
from py21cmfast._memory import estimate_memory_lightcone
user_params = UserParams(
{
"HII_DIM": 250,
"BOX_LEN": 2000.0,
"DIM": 1000,
"N_THREADS": 8,
"USE_RELATIVE_VELOCITIES": True,
"POWER_SPECTRUM": 5,
"USE_FFTW_WISDOM": True,
"PERTURB_ON_HIGH_RES": True,
"USE_INTERPOLATION_TABLES": True,
"FAST_FCOLL_TABLES": True,
}
)
flag_options = FlagOptions(
{
"INHOMO_RECO": True,
"USE_MASS_DEPENDENT_ZETA": True,
"USE_TS_FLUCT": True,
"USE_MINI_HALOS": True,
},
USE_VELS_AUX=True,
)
h2dim = np.array(list(range(200, 1500, 100)))
mems4 = []
for h2 in range(200, 1500, 100):
user_params.update(HII_DIM=h2, DIM=4 * h2)
mem = estimate_memory_lightcone(
max_redshift=1420 / 50 - 1,
redshift=1420 / 200 - 1,
user_params=user_params,
flag_options=flag_options,
cosmo_params=CosmoParams(),
astro_params=AstroParams(),
)
mems4.append(mem)
peaks4 = np.array([m["peak_memory"] / (1024**3) for m in mems4])
mems3 = []
for h2 in range(200, 1500, 100):
user_params.update(HII_DIM=h2, DIM=3 * h2)
mem = estimate_memory_lightcone(
max_redshift=1420 / 50 - 1,
redshift=1420 / 200 - 1,
user_params=user_params,
flag_options=flag_options,
cosmo_params=CosmoParams(),
astro_params=AstroParams(),
)
mems3.append(mem)
peaks3 = np.array([m["peak_memory"] / (1024**3) for m in mems3])
mems2 = []
for h2 in range(200, 1500, 100):
user_params.update(HII_DIM=h2, DIM=2 * h2)
mem = estimate_memory_lightcone(
max_redshift=1420 / 50 - 1,
redshift=1420 / 200 - 1,
user_params=user_params,
flag_options=flag_options,
cosmo_params=CosmoParams(),
astro_params=AstroParams(),
)
mems2.append(mem)
peaks2 = np.array([m["peak_memory"] / (1024**3) for m in mems2])
user_params.update(HII_DIM=1300, DIM=2600) # what we actually did.
mem = estimate_memory_lightcone(
max_redshift=1420 / 50 - 1,
redshift=1420 / 200 - 1,
user_params=user_params,
flag_options=flag_options,
cosmo_params=CosmoParams(),
astro_params=AstroParams(),
)
plt.plot(h2dim, peaks2, label="DIM=2*HII_DIM")
plt.plot(h2dim, peaks3, label="DIM=3*HII_DIM")
plt.plot(h2dim, peaks4, label="DIM=4*HII_DIM")
plt.scatter(
1300,
mem["peak_memory"] / 1024**3,
marker="*",
color="k",
label="Proposed Sims",
s=100,
zorder=3,
)
plt.scatter(
1300, 2924.847, marker="+", color="r", label="Measured Peak RAM", s=75, zorder=3
)
theory = h2dim**3
plt.plot(
h2dim,
theory * (peaks3.max() / theory.max()) * 1.2,
label="HII_DIM^3 scaling",
color="grey",
ls="--",
)
plt.axhline(4000, linestyle="dashed", color="k")
plt.text(h2dim[0], 4300, "Avail RAM on Bridges2-EM")
plt.legend()
plt.yscale("log")
plt.xscale("log")
plt.ylabel("Peak memory (GB)")
plt.xlabel("HII_DIM")
plt.savefig("peak_memory_usage.png") | 21cmFAST | /21cmFAST-3.3.1.tar.gz/21cmFAST-3.3.1/devel/estimated_mem_usage_plot.py | estimated_mem_usage_plot.py |
---
title: '21cmFAST v3: A Python-integrated C code for generating 3D realizations of the cosmic 21cm signal.'
tags:
- Python
- astronomy
- cosmology
- simulation
authors:
- name: Steven G. Murray
orcid: 0000-0003-3059-3823
affiliation: 1
- name: Bradley Greig
orcid: 0000-0002-4085-2094
affiliation: 2, 3
- name: Andrei Mesinger
orcid: 0000-0003-3374-1772
affiliation: 4
- name: Julian B. Muñoz
orcid: 0000-0002-8984-0465
affiliation: 5
- name: Yuxiang Qin
orcid: 0000-0002-4314-1810
affiliation: 4
- name: Jaehong Park
orcid: 0000-0003-3095-6137
affiliation: 4, 7
- name: Catherine A. Watkinson
orcid: 0000-0003-1443-3483
affiliation: 6
affiliations:
- name: School of Earth and Space Exploration, Arizona State University, Phoenix, USA
index: 1
- name: ARC Centre of Excellence for All-Sky Astrophysics in 3 Dimensions (ASTRO 3D)
index: 2
- name: School of Physics, University of Melbourne, Parkville, VIC 3010, Australia
index: 3
- name: Scuola Normale Superiore, Piazza dei Cavalieri 7, 56126 Pisa, Italy
index: 4
- name: Department of Physics, Harvard University, 17 Oxford St., Cambridge, MA, 02138, USA
index: 5
- name: School of Physics and Astronomy, Queen Mary University of London, G O Jones Building, 327 Mile End Road, London, E1 4NS, UK
index: 6
- name: School of Physics, Korea Institute for Advanced Study, 85 Hoegiro, Dongdaemun-gu, Seoul, 02455, Republic of Korea
index: 7
date: 24 Sep 2020
bibliography: paper.bib
---
# Summary
The field of 21-cm cosmology -- in which the hyperfine spectral line of neutral hydrogen
(appearing at the rest-frame wavelength of 21 cm) is mapped over large swathes of the
Universe's history -- has developed radically over the last decade.
The promise of the field is to revolutionize our
knowledge of the first stars, galaxies, and black holes through the timing and patterns
they imprint on the cosmic 21-cm signal.
In order to interpret the eventual observational data, a range of physical models have
been developed -- from simple analytic models of the global history of hydrogen reionization,
through to fully hydrodynamical simulations of the 3D evolution of the brightness
temperature of the spectral line.
Between these extremes lies an especially versatile middle-ground: fast semi-numerical
models that approximate the full 3D evolution of the relevant fields: density, velocity,
temperature, ionization, and radiation (Lyman-alpha, neutral hydrogen 21-cm, etc.).
These have the advantage of being comparable to the full first-principles
hydrodynamic simulations, but significantly quicker to run; so much so that they can
be used to produce thousands of realizations on scales comparable to those observable
by upcoming low-frequency radio telescopes, in order to explore the very wide
parameter space that still remains consistent with the data.
Amongst practitioners in the field of 21-cm cosmology, the `21cmFAST` program has become
the *de facto* standard for such semi-numerical simulators.
`21cmFAST` [@mesinger2007; @mesinger2010] is a high-performance C code that uses the
excursion set formalism [@furlanetto2004] to
identify regions of ionized hydrogen atop a cosmological density field evolved using
first- or second-order Lagrangian perturbation theory [@zeldovich1970; @scoccimarro2002],
tracking the thermal and ionization state of the intergalactic medium, and computing
X-ray, soft UV and ionizing UV cosmic radiation fields based on parametrized galaxy models.
For example, the following figure contains slices of lightcones (3D fields in which one
axis corresponds to both spatial *and* temporal evolution) for the various
component fields produced by `21cmFAST`.
{height=450px}
However, `21cmFAST` is a highly specialized code, and its implementation has been
quite specific and relatively inflexible.
This inflexibility makes it difficult to modify the behaviour of the code without detailed
knowledge of the full system, or disrupting its workings.
This lack of modularity within the code has led to
widespread code "branching" as researchers hack new physical features of interest
into the C code; the lack of a streamlined API has led derivative codes which run
multiple realizations of `21cmFAST` simulations [such as the Monte Carlo simulator,
`21CMMC`, @greig2015] to re-write large portions of the code in order to serve their purpose.
It is thus of critical importance, as the field moves forward in its understanding -- and
the range and scale of physical models of interest continues to increase -- to
reformulate the `21cmFAST` code in order to provide a fast, modular, well-documented,
well-tested, stable simulator for the community.
# Features of 21cmFAST v3
This paper presents `21cmFAST` v3+, which is formulated to follow these essential
guiding principles.
While keeping the same core functionality of previous versions of `21cmFAST`, it has
been fully integrated into a Python package, with a simple and intuitive interface, and
a great deal more flexibility.
At a higher level, in order to maintain best practices, a community of users and
developers has coalesced into a formal collaboration which maintains the project via a
Github organization.
This allows the code to be consistently monitored for quality, maintaining high test
coverage, stylistic integrity, dependable release strategies and versioning,
and peer code review.
It also provides a single point-of-reference for the community to obtain the code,
report bugs and request new features (or get involved in development).
A significant part of the work of moving to a Python interface has been the
development of a robust series of underlying Python structures which handle the passing
of data between Python and C via the `CFFI` library.
This foundational work provides a platform for future versions to extend the scientific
capabilities of the underlying simulation code.
The primary *new* usability features of `21cmFAST` v3+ are:
* Convenient (Python) data objects which simplify access to and processing of the various
fields that form the brightness temperature.
* Enhancement of modularity: the underlying C functions for each step of the simulation
have been de-coupled, so that arbitrary functionality can be injected into the process.
* Conversion of most global parameters to local structs to enable this modularity, and
also to obviate the requirement to re-compile in order to change parameters.
* Simple `pip`-based installation.
* Robust on-disk caching/writing of data, both for efficiency and simplified reading of
previously processed data (using HDF5).
* Simple high-level API to generate either coeval cubes (purely spatial 3D fields defined
at a particular time) or full lightcone data (i.e. those coeval cubes interpolated over
cosmic time, mimicking actual observations).
* Improved exception handling and debugging.
* Convenient plotting routines.
* Simple configuration management, and also more intuitive management for the
remaining C global variables.
* Comprehensive API documentation and tutorials.
* Comprehensive test suite (and continuous integration).
* Strict semantic versioning^[https://semver.org].
While in v3 we have focused on the establishment of a stable and extendable infrastructure,
we have also incorporated several new scientific features, appearing in separate papers:
* Generate transfer functions using the `CLASS` Boltzmann code [@Lesgourgues2011].
* Simulate the effects of relative velocities between dark matter and Baryons [@munoz2019a; @munoz2019b].
* Correction for non-conservation of ionizing photons (Park, Greig et al., *in prep*).
* Include molecularly cooled galaxies with distinct properties [@qin2020]
* Calculate rest-frame UV luminosity functions based on parametrized galaxy models.
`21cmFAST` is still in very active development.
Amongst further usability and performance improvements,
future versions will see several new physical models implemented,
including milli-charged dark matter models [@Munoz2018] and forward-modelled CMB
auxiliary data [@qin2020a].
In addition, `21cmFAST` will be incorporated into large-scale inference codes, such as
`21CMMC`, and is being used to create large data-sets for inference via machine learning.
We hope that with this new framework, `21cmFAST` will remain an important component
of 21-cm cosmology for years to come.
# Examples
`21cmFAST` supports installation using `conda`, which means installation is as simple
as typing `conda install -c conda-forge 21cmFAST`. The following example can then
be run in a Python interpreter.
In-depth examples can be found in the official documentation.
As an example of the simplicity with which a full lightcone may be produced with
the new `21cmFAST` v3, the following may be run in a Python interpreter (or Jupyter
notebook):
```python
import py21cmfast as p21c
lightcone = p21c.run_lightcone(
redshift=6.0, # Minimum redshift of lightcone
max_redshift=30.0,
user_params={
"HII_DIM": 150, # N cells along side in output cube
"DIM": 400, # Original high-res cell number
"BOX_LEN": 300, # Size of the simulation in Mpc
},
flag_options={
"USE_TS_FLUCT": True, # Don't assume saturated spin temp
"INHOMO_RECO": True, # Use inhomogeneous recombinations
},
lightcone_quantities=( # Components to store as lightcones
"brightness_temp",
"xH_box",
"density"
),
global_quantities=( # Components to store as mean
"xH_box", # values per redshift
"brightness_temp"
),
)
# Save to a unique filename hashing all input parameters
lightcone.save()
# Make a lightcone sliceplot
p21c.plotting.lightcone_sliceplot(lightcone, "brightness_temp")
```
{height=300px}
```python
# Plot a global quantity
p21c.plotting.plot_global_history(lightcone, "xH")
```
{height=300px}
# Performance
Despite being a Python code, `21cmFAST` v3 does not diminish the performance of previous
pure-C versions. It utilises `CFFI` to provide the interface to the C-code through
Python, which is managed by some custom Python classes that oversee the construction and
memory allocation of each C `struct`.
OpenMP parallelization is enabled within the C-code, providing excellent speed-up for
large simulations when performed on high-performance machines.
A simple performance comparison between v3 and v2.1 (the last pure-C version), running
a light-cone simulation over a redshift range between 35 and 5 (92 snapshots) with spin
temperature fluctuations (`USE_TS_FLUCT`), inhomogeneous recombinations
(`INHOMO_RECO`), FFTW Wisdoms (`USE_FFTW_WISDOM`) and interpolation tables
(`USE_INTERPOLATION_TABLES`),
with a resolution of `HII_DIM=250` cells, and `DIM=1000` cells for the initial conditions,
on an Intel(R) Xeon(R) CPU (E5-4657L v2 @ 2.40GHz) with 16 shared-memory cores, reveals
that a clock time of 7.63(12.63) hours and a maximum RAM of 224(105) gigabytes are needed
for v3(v2.1).
Note that while a full light-cone simulation can be expensive to perform,
it only takes 2-3min to calculate a Coeval box (excluding the initial conditions).
For instance, the aforementioned timing for v3 includes 80 minutes to generate the
initial condition, which also dominates the maximum RAM required, with an additional
~4 minutes per snapshot to calculate all required fields of perturbation, ionization,
spin temperature and brightness temperature.
To guide the user, we list some performance benchmarks for variations on this simulation,
run with `21cmFAST` v3.0.2. Note that these benchmarks are subject to change as new
minor versions are delivered; in particular, operational modes that reduce maximum
memory consumption are planned for the near future.
| Variation | Time (hr) | Memory (GB) |
| ----------------------------------------------- | --------- | ----------- |
| Reference | 7.63 | 224 |
| Single Core | 14.77 | 224 |
| 4 Shared-memory Cores | 7.42 | 224 |
| 64 Shared-memory Cores | 9.60 | 224 |
| Higher Resolution <br />(HII_DIM=500, DIM=2000) | 68.37 | 1790 |
| Lower Resolution <br />(HII_DIM=125, DIM=500) | 0.68 | 28 |
| No Spin Temperature | 4.50 | 224 |
| Use Mini-Halos | 11.57 | 233 |
| No FFTW Wisdoms | 7.33 | 224 |
At this time, the `21cmFAST` team suggests using 4 or fewer shared-memory cores.
However, it is worth noting that as performance does vary on different machines,
users are recommended to calculate their own scalability.
# Acknowledgements
This work was supported in part by the European Research Council
(ERC) under the European Union’s Horizon 2020 research
and innovation programme (AIDA – #638809). The results
presented here reflect the authors’ views; the ERC is not
responsible for their use. JBM was partially supported by NSF grant AST-1813694.
Parts of this research were supported by the European Research Council under ERC grant
number 638743-FIRSTDAWN. Parts of this research were supported by the Australian Research
Council Centre of Excellence for
All Sky Astrophysics in 3 Dimensions (ASTRO 3D), through project number CE170100013.
JP was supported in part by a KIAS individual Grant (PG078701) at Korea Institute for
Advanced Study.
# References
| 21cmFAST | /21cmFAST-3.3.1.tar.gz/21cmFAST-3.3.1/joss-paper/paper.md | paper.md |
MIT License
Copyright (c) 2022 [The_Robin_Hood]
Permission 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.
| 233-misc | /233_misc-0.0.3.tar.gz/233_misc-0.0.3/LICENSE.md | LICENSE.md |
import argparse
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--input', help='A 23andme data file', required=True)
parser.add_argument('--output', help='Output VCF file', required=True)
parser.add_argument('--fasta', help='An uncompressed reference genome GRCh37 fasta file', required=True)
parser.add_argument('--fai', help='The fasta index for for the reference', required=True)
def load_fai(args):
index = {}
with open(args.fai) as f:
for line in f:
toks = line.split('\t')
chrom = 'chr' + toks[0]
if chrom == 'chrMT':
chrom = 'chrM'
length = int(toks[1])
start = int(toks[2])
linebases = int(toks[3])
linewidth = int(toks[4])
index[chrom] = (start, length, linebases, linewidth)
return index
def get_vcf_records(pos_list, fai, args):
with open(args.fasta) as f:
def get_alts(ref, genotype):
for x in genotype:
assert x in 'ACGT'
if len(genotype) == 1:
if ref in genotype:
return []
return [genotype]
if ref == genotype[0] and ref == genotype[1]:
return []
if ref == genotype[0]:
return [genotype[1]]
if ref == genotype[1]:
return [genotype[0]]
return [genotype[0], genotype[1]]
for (rsid, chrom, pos, genotype) in pos_list:
start, _, linebases, linewidth = fai[chrom]
n_lines = int(pos / linebases)
n_bases = pos % linebases
n_bytes = start + n_lines * linewidth + n_bases
f.seek(n_bytes)
ref = f.read(1)
alts = get_alts(ref, genotype)
pos = str(pos + 1)
diploid = len(genotype) == 2
assert ref not in alts
assert len(alts) <= 2
if diploid:
if len(alts) == 2:
if alts[0] == alts[1]:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1/1')
else:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1/2')
yield (chrom, pos, rsid, ref, alts[1], '.', '.', '.', 'GT', '2/1')
elif len(alts) == 1:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '0/1')
elif len(alts) == 1:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1')
def load_23andme_data(input):
with open(input) as f:
for line in f:
if line.startswith('#'): continue
if line.strip():
rsid, chrom, pos, genotype = line.strip().split('\t')
if chrom == 'MT':
chrom = 'M'
chrom = 'chr' + chrom
if genotype != '--':
skip = False
for x in genotype:
if x not in 'ACTG':
skip = True
if not skip:
yield rsid, chrom, int(pos) - 1, genotype # subtract one because positions are 1-based indices
def write_vcf_header(f):
f.write(
"""##fileformat=VCFv4.2
##source=23andme_to_vcf
##reference=GRCh37
##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">
#CHROM POS ID REF ALT QUAL FILTER INFO FORMAT SAMPLE
""")
def write_vcf(outfile, records):
with open(outfile, 'w') as f:
write_vcf_header(f)
for record in records:
f.write('\t'.join(record) + '\n')
def main():
args = parser.parse_args()
fai = load_fai(args)
snps = load_23andme_data(args.input)
records = get_vcf_records(snps, fai, args)
write_vcf(args.output, records) | 23andme-to-vcf | /23andme_to_vcf-0.0.3-py3-none-any.whl/_23andme_to_vcf/driver.py | driver.py |
import argparse
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--input', help='A 23andme data file', required=True)
parser.add_argument('--output', help='Output VCF file', required=True)
def load_fai():
index = {}
with open('./data/GRCh37.fa.fai') as f:
for line in f:
toks = line.split('\t')
chrom = 'chr' + toks[0]
if chrom == 'chrMT':
chrom = 'chrM'
length = int(toks[1])
start = int(toks[2])
linebases = int(toks[3])
linewidth = int(toks[4])
index[chrom] = (start, length, linebases, linewidth)
return index
def get_vcf_records(pos_list, fai):
with open('./data/GRCh37.fa') as f:
def get_alts(ref, genotype):
for x in genotype:
assert x in 'ACTG'
if len(genotype) == 1:
if ref in genotype:
return []
return [genotype]
if ref == genotype[0] and ref == genotype[1]:
return []
if ref == genotype[0]:
return [genotype[1]]
if ref == genotype[1]:
return [genotype[0]]
return [genotype[0], genotype[1]]
for (rsid, chrom, pos, genotype) in pos_list:
start, _, linebases, linewidth = fai[chrom]
n_lines = int(pos / linebases)
n_bases = pos % linebases
n_bytes = start + n_lines * linewidth + n_bases
f.seek(n_bytes)
ref = f.read(1)
alts = get_alts(ref, genotype)
pos = str(pos + 1)
diploid = len(genotype) == 2
assert ref not in alts
assert len(alts) <= 2
if diploid:
if len(alts) == 2:
if alts[0] == alts[1]:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1/1')
else:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1/2')
yield (chrom, pos, rsid, ref, alts[1], '.', '.', '.', 'GT', '2/1')
elif len(alts) == 1:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '0/1')
elif len(alts) == 1:
yield (chrom, pos, rsid, ref, alts[0], '.', '.', '.', 'GT', '1')
def load_23andme_data(input):
with open(input) as f:
for line in f:
if line.startswith('#'): continue
if line.strip():
rsid, chrom, pos, genotype = line.strip().split('\t')
if chrom == 'MT':
chrom = 'M'
chrom = 'chr' + chrom
if genotype != '--':
skip = False
for x in genotype:
if x not in 'ACTG':
skip = True
if not skip:
yield rsid, chrom, int(pos) - 1, genotype # subtract one because positions are 1-based indices
def write_vcf_header(f):
f.write(
"""
##fileformat=VCFv4.2
##source=23andme_to_vcf
##reference=GRCh37
##FORMAT=<ID=GT,Number=1,Type=String,Description="Genotype">
#CHROM POS ID REF ALT QUAL FILTER INFO FORMAT SAMPLE
""")
def write_vcf(outfile, records):
with open(outfile, 'w') as f:
write_vcf_header(f)
for record in records:
f.write('\t'.join(record) + '\n')
def main():
args = parser.parse_args()
fai = load_fai()
snps = load_23andme_data(args.input)
records = get_vcf_records(snps, fai)
write_vcf(args.output, records) | 23andme-to-vcf | /23andme_to_vcf-0.0.3-py3-none-any.whl/23andme_to_vcf/driver.py | driver.py |
import os
import sys
import time
import signal
import math
import random
import itertools
import csv
def calc(a, o, b):
P = {'+': 1, '-': 1, '*': 2, '/': 2}
ea, eb = a['e'], b['e']
va, vb = eval(a['e']), eval(b['e'])
c = a['c'] + b['c']
if 'o' in a and P[a['o']] < P[o]:
ea = '(' + a['e'] + ')'
if 'o' in b and P[o] > P[b['o']]:
eb = '(' + b['e'] + ')'
if 'o' in b and P[o] == P[b['o']]:
if (o == '+' and b['o'] == '+') or (o == '*' and b['o'] == '*'):
pass
else:
eb = '(' + b['e'] + ')'
e = ea + o + eb
if o == '+':
c += 1
if va + vb == 24:
pass
else: #和越大越复杂
t = va + vb
if t <= 10:
pass
else:
c += t*1.2
elif o == '-':
c += 1
t = va - vb
if t < 0: #减出负数
c += 100
elif o == '*':
c += 1
if va == 1 and vb == 1: #与1相乘不增加复杂度
pass
elif va * vb == 24:
pass
else: #积越大越复杂
t = va * vb
if t <= 10:
pass
else:
c += t
elif o == '/':
c += 2
if va == vb: #相同数相除不增加复杂度
pass
else:
c += 3
y = math.modf(va / vb)[0]
if y > 0: # 商为小数
c += 800
if math.modf(y * 100000)[0] > 0: #无理数
c += 800
return {'r': eval(e), 'e': e, 'o': o, 'c': int(c)}
def get1(a):
return [{'r': a, 'e': str(a), 'c': 0}]
def get2(a, b):
A = a if isinstance(a, list) else get1(a)
B = b if isinstance(b, list) else get1(b)
z = [ ]
for a in A:
for b in B:
if a['c'] < b['c']:
z.append(calc(b, '+', a))
z.append(calc(b, '*', a))
else:
z.append(calc(a, '+', b))
z.append(calc(a, '*', b))
z.append(calc(a, '-', b))
z.append(calc(b, '-', a))
if b['r'] != 0: z.append(calc(a, '/', b))
if a['r'] != 0: z.append(calc(b, '/', a))
return z
def get3(a, b, c):
return get2(a, get2(b, c)) + \
get2(b, get2(a, c)) + \
get2(c, get2(a, b))
def get4(a, b, c, d):
return get2(get2(a, b), get2(c, d)) + \
get2(get2(a, c), get2(b, d)) + \
get2(get2(a, d), get2(b, c)) + \
get2(a, get3(b, c, d)) + \
get2(b, get3(a, c, d)) + \
get2(c, get3(a, b, d)) + \
get2(d, get3(a, b, c))
def fx(target, values):
n = len(values)
if n == 4:
z = get4(values[0], values[1], values[2], values[3])
elif n == 3:
z = get3(values[0], values[1], values[2])
return list(filter(lambda x: math.isclose(x['r'], target, rel_tol=1e-10), z))
def fy(z, complex_fold=True):
z.sort(key=lambda x: x['c'])
e = []
c = []
d = []
for a in z:
if a['e'] not in e:
if complex_fold and a['c'] in c: continue
e.append(a['e'])
c.append(a['c'])
d.append({'e': str(round(a['r'])) + '=' + a['e'], 'c': a['c']})
return d
################################
C = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] * 4
def All():
D = list(itertools.combinations(C,4))
S = []
for v in D:
u = [v[0], v[1], v[2], v[3]]
u.sort()
if u not in S:
S.append(u)
return S
def sigint_handler(signum, frame):
print ('catched interrupt signal!')
exit()
status = ''
start = 0
result = []
def new_question(space):
global status, start, result
v, b = [], []
while True:
v = list(random.choice(space))
b = fx(24, v)
if len(b) > 0: break
os.system('clear')
print('')
print('\u2661', '\u2664', ' {} {} {} {} '.format(v[0], v[1], v[2], v[3]), '\u2667', '\u2662')
status = "new question"
start = int(time.time())
return b
def show_answer(d, n, f, delta):
global status, start, result
r = fy(d, f)
if n == 1:
print(r[0]["e"])
print("")
print("complexity", r[0]["c"])
print("total", len(r), "solutions")
print("cost", delta, "seconds")
else:
for i, a in enumerate(r):
if i < n:
print('{0:<16}{1}'.format(a['e'], a['c']))
status = "show answer"
def main():
global status, start, result
if len(sys.argv) >= 2:
if sys.argv[1] in ['-h', '-H', '--help']:
print('24p 1 2 3 4 # for query')
print('24p # for play game')
return
signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGHUP, sigint_handler)
signal.signal(signal.SIGTERM, sigint_handler)
v = list(map(lambda x: int(x), sys.argv[1:]))
n = len(v)
if n == 0:
space = list(itertools.combinations(C,4))
result = new_question(space)
while True:
Q = input('')
if Q == 'q': exit()
if status == "new question":
delta = int(time.time()) - start
if Q == "":
show_answer(result, 1, True, delta)
else:
if Q == "a": show_answer(result, 99999, False, delta)
elif Q == "b": show_answer(result, 99999, True, delta)
elif Q == "n": show_answer(result, 99999, True, delta)
print("cost ", delta, " seconds")
elif status == "show answer":
if Q == "a": show_answer(result, 99999, False, 0)
elif Q == "b": show_answer(result, 99999, True, 0)
else: result = new_question(space)
if n == 1:
Q = int(sys.argv[1])
S = All()
for i, v in enumerate(S):
b = fx(24, v)
b.sort(key=lambda x: x['c'])
if len(b) > 0:
a = b[0]
if Q < a['c']:
print('{}%'.format(int(i/len(S) * 100)), v, '{0:>4}={1:<16}{2}'.format(int(a['r']), a['e'], a['c']))
if n == 2:
Q1 = int(sys.argv[1])
Q2 = int(sys.argv[2])
S = All()
for i, v in enumerate(S):
b = fx(24, v)
b.sort(key=lambda x: x['c'])
if len(b) > 0:
a = b[0]
if Q1 < a['c'] and a['c'] < Q2:
print('{}%'.format(int(i/len(S) * 100)), v, '{0:>4}={1:<16}{2}'.format(int(a['r']), a['e'], a['c']))
if n == 3:
for a in ['3', '4', '6', '8', '12', '1/3', '1/4', '1/6', '1/8', '24', '48', '72', '96']:
r = eval('1.0*' + a)
b = fx(r, v)
b.sort(key=lambda x: x['c'])
if len(b) > 0:
print(a +'='+ b[0]['e'])
if n == 4:
show_answer(fx(24, v), 99999, False, 0) | 24p | /24p-0.2.0-py3-none-any.whl/p24/p24.py | p24.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Gaussian(Distribution):
""" Gaussian distribution class for calculating and
visualizing a Gaussian distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats extracted from the data file
"""
def __init__(self, mu=0, sigma=1):
Distribution.__init__(self, mu, sigma)
def calculate_mean(self):
"""Function to calculate the mean of the data set.
Args:
None
Returns:
float: mean of the data set
"""
avg = 1.0 * sum(self.data) / len(self.data)
self.mean = avg
return self.mean
def calculate_stdev(self, sample=True):
"""Function to calculate the standard deviation of the data set.
Args:
sample (bool): whether the data represents a sample or population
Returns:
float: standard deviation of the data set
"""
if sample:
n = len(self.data) - 1
else:
n = len(self.data)
mean = self.calculate_mean()
sigma = 0
for d in self.data:
sigma += (d - mean) ** 2
sigma = math.sqrt(sigma / n)
self.stdev = sigma
return self.stdev
def plot_histogram(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.hist(self.data)
plt.title('Histogram of Data')
plt.xlabel('data')
plt.ylabel('count')
def pdf(self, x):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
return (1.0 / (self.stdev * math.sqrt(2*math.pi))) * math.exp(-0.5*((x - self.mean) / self.stdev) ** 2)
def plot_histogram_pdf(self, n_spaces = 50):
"""Function to plot the normalized histogram of the data and a plot of the
probability density function along the same range
Args:
n_spaces (int): number of data points
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
mu = self.mean
sigma = self.stdev
min_range = min(self.data)
max_range = max(self.data)
# calculates the interval between x values
interval = 1.0 * (max_range - min_range) / n_spaces
x = []
y = []
# calculate the x values to visualize
for i in range(n_spaces):
tmp = min_range + interval*i
x.append(tmp)
y.append(self.pdf(tmp))
# make the plots
fig, axes = plt.subplots(2,sharex=True)
fig.subplots_adjust(hspace=.5)
axes[0].hist(self.data, density=True)
axes[0].set_title('Normed Histogram of Data')
axes[0].set_ylabel('Density')
axes[1].plot(x, y)
axes[1].set_title('Normal Distribution for \n Sample Mean and Sample Standard Deviation')
axes[0].set_ylabel('Density')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Gaussian distributions
Args:
other (Gaussian): Gaussian instance
Returns:
Gaussian: Gaussian distribution
"""
result = Gaussian()
result.mean = self.mean + other.mean
result.stdev = math.sqrt(self.stdev ** 2 + other.stdev ** 2)
return result
def __repr__(self):
"""Function to output the characteristics of the Gaussian instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}".format(self.mean, self.stdev) | 29082022-distributions | /29082022_distributions-0.1.tar.gz/29082022_distributions-0.1/29082022_distributions/Gaussiandistribution.py | Gaussiandistribution.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Binomial(Distribution):
""" Binomial distribution class for calculating and
visualizing a Binomial distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats to be extracted from the data file
p (float) representing the probability of an event occurring
n (int) number of trials
TODO: Fill out all functions below
"""
def __init__(self, prob=.5, size=20):
self.n = size
self.p = prob
Distribution.__init__(self, self.calculate_mean(), self.calculate_stdev())
def calculate_mean(self):
"""Function to calculate the mean from p and n
Args:
None
Returns:
float: mean of the data set
"""
self.mean = self.p * self.n
return self.mean
def calculate_stdev(self):
"""Function to calculate the standard deviation from p and n.
Args:
None
Returns:
float: standard deviation of the data set
"""
self.stdev = math.sqrt(self.n * self.p * (1 - self.p))
return self.stdev
def replace_stats_with_data(self):
"""Function to calculate p and n from the data set
Args:
None
Returns:
float: the p value
float: the n value
"""
self.n = len(self.data)
self.p = 1.0 * sum(self.data) / len(self.data)
self.mean = self.calculate_mean()
self.stdev = self.calculate_stdev()
def plot_bar(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.bar(x = ['0', '1'], height = [(1 - self.p) * self.n, self.p * self.n])
plt.title('Bar Chart of Data')
plt.xlabel('outcome')
plt.ylabel('count')
def pdf(self, k):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
a = math.factorial(self.n) / (math.factorial(k) * (math.factorial(self.n - k)))
b = (self.p ** k) * (1 - self.p) ** (self.n - k)
return a * b
def plot_bar_pdf(self):
"""Function to plot the pdf of the binomial distribution
Args:
None
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
x = []
y = []
# calculate the x values to visualize
for i in range(self.n + 1):
x.append(i)
y.append(self.pdf(i))
# make the plots
plt.bar(x, y)
plt.title('Distribution of Outcomes')
plt.ylabel('Probability')
plt.xlabel('Outcome')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Binomial distributions with equal p
Args:
other (Binomial): Binomial instance
Returns:
Binomial: Binomial distribution
"""
try:
assert self.p == other.p, 'p values are not equal'
except AssertionError as error:
raise
result = Binomial()
result.n = self.n + other.n
result.p = self.p
result.calculate_mean()
result.calculate_stdev()
return result
def __repr__(self):
"""Function to output the characteristics of the Binomial instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}, p {}, n {}".\
format(self.mean, self.stdev, self.p, self.n) | 29082022-distributions | /29082022_distributions-0.1.tar.gz/29082022_distributions-0.1/29082022_distributions/Binomialdistribution.py | Binomialdistribution.py |
# Background and Validation
This wiki is built in Notion. Here are all the tips you need to contribute.
# General Background
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Map-1_Step-.jpg" alt="Flow over a cylinder" width="700"/>
Flow over a cylinder
---
> **The project has been started as a Open Source repository for CFD solvers. The motive is to provide handy easy to understand code with multitude of CFD schemes for cfd developers. Also, needs to remain functional as an easy to setup open source solver for users. This release only comprises of a terminal sequential prompt, simple and effective. We have immediate plans of implementing a PyQT GUI to it.**
>
> Head to the notion page for more information on how to add to this project:
>
[https://florentine-hero-1e6.notion.site/2D_Panel-CFD-ad63baa924ee4a32af8a52b8134c0360](https://www.notion.so/2D_Panel-CFD-ad63baa924ee4a32af8a52b8134c0360)
> **This version comprises of a 2D Staggered Grid with Inlet, Outlet & Wall Boundary conditions. Obstacles can be imported & transformed with a list of points or with the inbuilt elliptical geometries.**
>
> **First order Upwind Scheme is used for Velocity with very good results for the benchmark Lid Driven Cavity problem when compared to results in Ghia etal.**
>
> **The SIM runs stable with terminal-python for <10000 Cells after which Residual plotting becomes laggy. spyder (Anaconda IDE) provides great speed-ups with multi-core utilisation & also improves the post-processing experience. The Sequential prompts based model is based on a GUI approach and will be ported to it in the next update.**
>
> **The lack of multi-threading support in python trumps the ease of accessibility of matplotlib library. We will be looking to port into C++ immediately utilizing vtk libraries with paraview & blender for visualization.**
>
> **The framework is designed to test new FVM schemes, & Coupling solvers. All popular convection schemes will be added soon. Multiple solvers will be available in the next updates, the likes of SIMPLER, PISO, Pimple etc. Future plans also include Unsteady & VOF solvers.**
>
> **The program works as a sequential prompt, for SIM Parameters. The prompts are designed keeping in mind a GUI approach, which will be available in the next update. There are frequent Check Cycles to render the result & modify any inputs. We'll go through an exemplary First Run in the next Section.**
>
# Installation
### Method: 1
To install using pip Run:
```python
python3 -m pip install 2D_Panel-CFD
```
Or:
### Method: 2
[https://github.com/Fluidentity/2D_Panel-CFD](https://github.com/Fluidentity/2D_Panel-CFD)
- Clone github `[RUN_package](https://github.com/Fluidentity/2D_Panel-CFD.git)` to anywhere in your machine from:
```tsx
cd /insert/folder/address/cfd
git clone https://github.com/Fluidentity/2D_Panel-CFD.git
```
- Set it to PYTHONPATH with:
```python
export PYTHONPATH="${PYTHONPATH}:/insert/folder/address/cfd/RUN_package"
```
It's advisable to run this package from [RUN-spyder.py](http://RUN-spyder.py) through an IDE like spyder for ease of use, and prolonged variable storage. Also, spyder has some great plotting interface.
## Executable
<aside>
💡 The source directory should be set up as PYTHONPATH if not installed using pip
</aside>
### Method: 1
Open python environment with: (in terminal)
```python
python3
```
or (if python —version is >3)
```python
python
```
then insert:
```python
from RUN_package import RUN
```
- **RUN.py** is meant to be run from terminal.
### Method: 2
Run on IDE by cloning [RUN_package](https://github.com/Fluidentity/2D_Panel-CFD/tree/main/RUN_package) from Github.
> Open python IDE like spyder from RUN_package directory:
>
> Run RUN-spyder.py
>
The cells for pre-processor, solver & post processors are different. Need to run all.
- **RUN_spyder.py** can be run with an IDE, such as spyder to improve multi-Core Utilisation & post-processing experience. ****
# Validation of Solver
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/ezgif.com-gif-maker(3).gif" alt="Vortex Shedding flow over a cylinder" width="700"/>
Vortex Shedding flow over a cylinder
---
> For validation of the solver laid out, following strategies are used:
>
1. Comparison with Benchmark Problem Lid Driven Cavity
1. Reference study Ghia etal. Re = 100, 1000, 5000
## Lid Driven Cavity Benchmark Ghia etal.
### **Residuals**
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled.png" alt="Untitled" width="400"/>
### **Benchmark Test at Re=100**
- First Order Upwind scheme
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%201.png" alt="Untitled" width="400"/>
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%202.png" alt="Untitled" width="400"/>
### **Benchmark Test at Re=1000**
- First Order Upwind scheme
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%203.png" alt="Untitled" width="400"/>
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%204.png" alt="Untitled" width="400"/>
### **Benchmark Test at Re=5000**
- First Order Upwind scheme
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%205.png" alt="Untitled" width="400"/>
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%206.png" alt="Untitled" width="400"/>
### Conclusion
First order UPWIND Scheme is good for low Reynolds no. but is only first order accurate to capture higher gradient.
## Fully developed flow between Parallel Plates
### Velocity Profile [at X=0.8*Lx and Y=0.5*Ly]
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%207.png" alt="Untitled" width="400"/>
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Untitled%208.png" alt="Untitled" width="400"/>
<img src="https://github.com/Fluidentity/2D_Panel-CFD-/blob/main/img/Map-1_Step-200.jpg" alt="Map-1 Step-[200].jpg" width="1500"/>
### Conclusion
The Umax Velocity comes close to 1.5 feactor for steady flow between parallel plates. First order UPWIND Scheme with high y-gradient.
| 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/README.md | README.md |
import numpy as np
import matplotlib
from matplotlib import pyplot as plt
import matplotlib.animation as animation
matplotlib.rcParams.update({'font.size': 15})
def postProcessor(P_values, uxq_values, uyq_values, xMin, xMax, yMin, yMax, nx, ny, dx, dy, Points_x, Points_y, caseFolder, Res_U_values, Res_V_values, Res_Mass_values, max_iter, min_Res, max_Res):
('plasma')
flag_generateResults = int(input("\n1. Generate Results\n2. Abort\n"))
flag_newMap = 'y'
flag_newMapOK = 2
if(flag_generateResults==1):
flag_generateResidualsPlot = input("Generate Residuals plot ?? [y/n]")
if(flag_generateResidualsPlot=='y'):
fig, ax = fig, ax = plt.subplots(figsize =(10, 5))
iter_ = np.linspace(0, max_iter, max_iter)
ax.plot(iter_, Res_U_values, color = 'red', label = 'Ux-Mom Residual')
ax.plot(iter_, Res_V_values, color = 'blue', label = 'Uy-Mom Residual')
ax.plot(iter_, Res_Mass_values, color = 'green', label = 'Mass Residual')
ax.set_ylim(min_Res, max_Res)
ax.set_xlim(0, max_iter)
ax.set_xlabel('Iterations')
ax.legend()
plt.savefig(caseFolder+"/Residuals.jpg")
flag_generateCSV = int(input("\n[1]- Generate CSV files of Residuals \n[2]- Generate CSV files of U, V and P\n[3]- No CSV Results\n"))
if(flag_generateCSV==1):
np.savetxt(caseFolder+"/U_Residual.csv", Res_U_values, delimiter=",")
np.savetxt(caseFolder+"/V-Residual.csv", Res_V_values, delimiter=",")
np.savetxt(caseFolder+"/Mass_Residual.csv", Res_Mass_values, delimiter=",")
elif(flag_generateCSV==2):
np.savetxt(caseFolder+"/U.csv", uxq_values[max_iter-1], delimiter=",")
np.savetxt(caseFolder+"/V.csv", uyq_values[max_iter-1], delimiter=",")
np.savetxt(caseFolder+"/P.csv", P_values[max_iter], delimiter=",")
mapCounter = 1
matplotlib.rcParams.update({'font.size': 35})
while(flag_newMap=='y'):
print("Generating Map-", mapCounter)
flag_resultColorMap = input("Add ColorMap ?? [y/n]")
flag_resultGeometry = input("Add Black Obstacle Geometry ?? [y/n]")
if(flag_resultColorMap=='y'):
flag_resultColorMapMarker = int(input("\nSelect Variable\n[1]- Pressure\n[2]- Velocity\n[3]- X-Velocity\n[4]- Y-Velocity\n"))
flag_resultColorMapContourlines = input("\nWith Labelled Contourlines ?? [y/n]\n")
if(flag_resultColorMapContourlines=='y'):
ContourlinesDensity = int(20/int(input("\nDensity of Contourlines ??\n")))
min_resultColorMap = float(input("Min value of variable"))
max_resultColorMap = float(input("Max value of variable"))
flag_resultStreamlines = input("Add Streamlines ?? [y/n]")
if(flag_resultStreamlines=='y'):
flag_resultStreamlinesDensity = int(input("Streamlines Density ??"))
flag_resultVectors = input("Add Vectors ?? [y/n]")
xq = np.linspace(xMin, xMax, num=2*nx+1)
yq = np.linspace(yMax, yMin, num=2*ny+1)
xqs = np.linspace(xMin, xMax, num=2*nx+1)
yqs = np.linspace(yMin, yMax, num=2*ny+1)
xp = np.linspace(xMin+dx/2, xMax-dx/2, num=nx)
yp = np.linspace(yMax-dy/2, yMin+dy/2, num=ny)
Xq, Yq = np.meshgrid(xqs, yqs)
# creating plot
Lx = xMax-xMin
Ly = yMax-yMin
fig, ax = plt.subplots(figsize =(Lx*10, Ly*10))
if(flag_resultGeometry=='y'):
ax.fill(Points_x, Points_y, color='black')
if(flag_resultColorMap=='y'):
levels = np.linspace(min_resultColorMap, max_resultColorMap, num=20)
if(flag_resultColorMapMarker==1):
contf = ax.contourf(xp, yp, P_values[max_iter-1], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
cbar = fig.colorbar(contf)
cbar.set_label('P')
elif(flag_resultColorMapMarker==2):
contf = ax.contourf(xq, yq, np.sqrt(uxq_values[max_iter-1]**2+uyq_values[max_iter-1]**2), levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
cbar = fig.colorbar(contf)
cbar.set_label('Vel')
elif(flag_resultColorMapMarker==3):
contf = ax.contourf(xq, yq, uxq_values[max_iter-1], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
cbar = fig.colorbar(contf)
cbar.set_label('Vel_x')
elif(flag_resultColorMapMarker==4):
contf = ax.contourf(xq, yq, uyq_values[max_iter-1], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
cbar = fig.colorbar(contf)
cbar.set_label('Vel_y')
if(flag_resultStreamlines=='y'):
ax.streamplot(Xq, Yq, np.flip(uxq_values[max_iter-1], 0) ,np.flip(uyq_values[max_iter-1], 0), density=flag_resultStreamlinesDensity, color='black', linewidth=1)
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([xMin, xMax, yMin, yMax])
ax.set_aspect('equal')
elif(flag_resultVectors=='y'):
ax.quiver(Xq, Yq, np.flip(uxq_values[max_iter-1], 0) ,np.flip(uyq_values[max_iter-1], 0))
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([xMin, xMax, yMin, yMax])
ax.set_aspect('equal')
# show plot
plt.show()
flag_newMapOK = int(input("\n1. Continue with Map \n2. Generate again \n"))
if(flag_newMapOK==2):
continue
flag_plotall = int(input("\n0. Plot Last frame only [n] - [jpg]\n1. Plot every n iterations - [GIF]\n"))
if(flag_plotall!=0):
xq = np.linspace(xMin, xMax, num=2*nx+1)
yq = np.linspace(yMin, yMax, num=2*ny+1)
xp = np.linspace(xMin+dx/2, xMax-dx/2, num=nx)
yp = np.linspace(yMax-dy/2, yMin+dy/2, num=ny)
Xq, Yq = np.meshgrid(xq, yq)
Lx = xMax-xMin
Ly = yMax-yMin
fig, ax = plt.subplots(figsize =(Lx*10, Ly*10))
if(flag_resultColorMap=='y'):
levels = np.linspace(min_resultColorMap, max_resultColorMap, num=20)
if(flag_resultColorMapMarker==1):
contf = ax.contourf(xp, yp, P_values[0], levels=levels, cmap=plt.cm.plasma)
cbar = fig.colorbar(contf)
cbar.set_label('P')
elif(flag_resultColorMapMarker==2):
contf = ax.contourf(xq, yq, np.sqrt(uxq_values[0]**2+uyq_values[0]**2), levels=levels, cmap=plt.cm.plasma)
cbar = fig.colorbar(contf)
cbar.set_label('Vel')
elif(flag_resultColorMapMarker==3):
contf = ax.contourf(xq, yq, uxq_values[0], levels=levels, cmap=plt.cm.plasma)
cbar = fig.colorbar(contf)
cbar.set_label('Vel_x')
elif(flag_resultColorMapMarker==4):
contf = ax.contourf(xq, yq, uyq_values[0], levels=levels, cmap=plt.cm.plasma)
cbar = fig.colorbar(contf)
cbar.set_label('Vel_y')
def animate(i):
ax.clear()
if(flag_resultGeometry=='y'):
ax.fill(Points_x, Points_y, color='black')
if(flag_resultColorMap=='y'):
levels = np.linspace(min_resultColorMap, max_resultColorMap, num=20)
if(flag_resultColorMapMarker==1):
contf = ax.contourf(xp, yp, P_values[i], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
# cbar = fig.colorbar(contf)
# cbar.set_label('P')
elif(flag_resultColorMapMarker==2):
contf = ax.contourf(xq, yq, np.sqrt(uxq_values[i]**2+uyq_values[i]**2), levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
# cbar = fig.colorbar(contf)
# cbar.set_label('Vel')
elif(flag_resultColorMapMarker==3):
contf = ax.contourf(xq, yq, uxq_values[i], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
# cbar = fig.colorbar(contf)
# cbar.set_label('Vel_x')
elif(flag_resultColorMapMarker==4):
contf = ax.contourf(xq, yq, uyq_values[i], levels=levels, cmap=plt.cm.plasma)
if(flag_resultColorMapContourlines=='y'):
cont = ax.contour(contf, levels=contf.levels[::ContourlinesDensity], colors='r')
# ax.clabel(cont, colors='w', fontsize=14)
# cbar = fig.colorbar(contf)
# cbar.set_label('Vel_y')
if(flag_resultStreamlines=='y'):
ax.streamplot(Xq, Yq, np.flip(uxq_values[i], 0) ,np.flip(uyq_values[i], 0), density=flag_resultStreamlinesDensity, color='black', linewidth=1)
elif(flag_resultVectors=='y'):
ax.quiver(Xq, Yq, np.flip(uxq_values[i], 0) ,np.flip(uyq_values[i], 0))
ax.set_title('Map-{} Step-[{}]'.format(mapCounter, i))
interval = 0.1
ani = animation.FuncAnimation(fig ,animate, max_iter, interval=interval*1e+3,blit=False)
writergif = animation.PillowWriter(fps=10)
ani.save(caseFolder+"/Map-{}.gif".format(mapCounter), writer = writergif)
if(flag_plotall==0):
fig.savefig(caseFolder+"/Map-{} Step-[{}].jpg".format(mapCounter, max_iter))
flag_newMap = input("Generate another Map ?? [y/n]")
mapCounter+=1 | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/postProcessing.py | postProcessing.py |
import numpy as np
from matplotlib import pyplot as plt
import os
def domain(caseFolder):
# Domain input
xMin = float(input("\nEnter X_min value\n"))
xMax = float(input("\nEnter X_max value\n"))
dx_temp = float(input("\nEnter Cell size in X-axis [dx]\n"))
nx = int((xMax-xMin)/dx_temp)
dx = (xMax-xMin)/nx
print("\n--- No. of elements in X-axis [{}] ---\n".format(nx))
yMin = float(input("\nEnter Y_min value\n"))
yMax = float(input("\nEnter Y_max value\n"))
dy_temp = float(input("\nEnter Cell size in Y-axis [dy]\n"))
ny = int((yMax-yMin)/dy_temp)
dy = (yMax-yMin)/ny
print("\n--- No. of elements in Y-axis [{}] ---\n".format(ny))
temp = "/boundary.txt"
boundary_info = open(caseFolder+temp, 'w')
# Boundary revealing Matrix
B1 = 2*np.ones((ny+1, nx+1))
# Scalar Matrix [U, V, P]
B2 = -1000.5*np.ones((ny+1, nx+1))
# Domain Matrix
D = []
D.append(B1)
D.append(B2)
D.append(B2.copy())
D.append(B2.copy())
# Boundary Definition
flag_Boundary = 0
flag_SouthBoundary = 0
flag_NorthBoundary = 0
flag_WestBoundary = 0
flag_EastBoundary = 0
flag_Outlet = 0
# Boundary Defining Loop
while (flag_Boundary < 1):
# Southern Boundary Defining Loop
while (flag_SouthBoundary < 1):
flag_Inlet_SouthBoundary = 0
flag_Outlet_SouthBoundary = 0
flag_SlidingWall_SouthBoundary = 0
flag = input("\nInlet in South Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Inlet_SouthBoundary = 1
flag = input("\nSliding Wall in South Boundary ?? [y/n]\n")
if(flag=='y'):
flag_SlidingWall_SouthBoundary = 1
flag = input("\nOutlet in South Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Outlet_SouthBoundary = 1
# Initialising Boundary Markers
south_Boundary = np.zeros((3, 6))
south_Boundary[1, 0] = 1
south_Boundary[2, 0] = -1
# Temporary Wall
south_Boundary[0, 1] = xMin
south_Boundary[0, 2] = xMax
D[0][-1, :] = 0
D[1][-1, :] = 0
D[2][-1, :] = 0
# South Boundary Sliding U-velocity
if(flag_SlidingWall_SouthBoundary==1):
south_Boundary[0, 3] = float(input("\nEnter U-Velocity for Sliding Wall in South Boundary\n"))
D[1][-1, 1:nx] = south_Boundary[0, 3]
# Inlet definition in South Boundary
if(flag_Inlet_SouthBoundary==1):
south_Boundary[1, 1] = float(input("\nEnter xmin for Inlet in South Boundary\n"))
southInlet_min_index = int((south_Boundary[1, 1]-xMin)/dx)
if(southInlet_min_index==0):
southInlet_min_index+=1
south_Boundary[1, 2] = float(input("\nEnter xmax for Inlet in South Boundary\n"))
southInlet_max_index = int((south_Boundary[1, 2]-xMin)/dx)
if(southInlet_max_index==nx):
southInlet_max_index-=1
south_Boundary[1, 4] = float(input("\nEnter V-Velocity for Inlet in South Boundary\n"))
# Boundary Marker
D[0][-1, southInlet_min_index:southInlet_max_index+1] = 1.0
# U-vel - Initialised to 0
D[1][-1, southInlet_min_index:southInlet_max_index+1] = 0
# V-vel - User Initialised
D[2][-1, southInlet_min_index:southInlet_max_index+1] = south_Boundary[1, 4]
# Outlet definition in South Boundary
if(flag_Outlet_SouthBoundary==1):
flag_Outlet = 1
south_Boundary[2, 1] = float(input("\nEnter xmin for Outlet in South Boundary\n"))
southOutlet_min_index = int((south_Boundary[2, 1]-xMin)/dx)
if(southOutlet_min_index==0):
southOutlet_min_index+=1
south_Boundary[2, 2] = float(input("\nEnter xmax for Outlet in South Boundary\n"))
southOutlet_max_index = int((south_Boundary[2, 2]-xMin)/dx)
if(southOutlet_max_index==nx):
southOutlet_max_index-=1
south_Boundary[2, 5] = float(input("\nEnter Pressure for Outlet in South Boundary\n"))
# Boundary Marker
D[0][-1, southOutlet_min_index:southOutlet_max_index+1] = -1.0
# U-vel - Uninitialised
D[1][-1, southOutlet_min_index:southOutlet_max_index+1] = -1000.5
# V-vel - Uninitialised
D[2][-1, southOutlet_min_index:southOutlet_max_index+1] = -1000.5
# Pressure - User Initialised
D[3][-1, southOutlet_min_index:southOutlet_max_index+1] = south_Boundary[2, 5]
print("\n\n------------------SOUTH BOUNDARY------------------\n")
boundary_info.write("\n\n------------------SOUTH BOUNDARY------------------\n")
ite=0
while ite<nx+1:
if(D[0][-1, ite]==0):
ite1=ite+1
if(ite1==nx+1 and D[0][-1, ite-1]!=0):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
while ite1<nx+1:
if(D[0][-1, ite1]!=0):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
if(flag_SlidingWall_SouthBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[1][-1, ite1-1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[1][-1, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
if(flag_SlidingWall_SouthBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[1][-1, ite1-1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[1][-1, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
if(D[0][-1, ite]==1):
ite1 = ite+1
while ite1<nx+1:
if(D[0][-1, ite1]!=1):
print("\n[Inlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
print("\nInlet V-Velocity {}\n".format(D[2][-1, ite1-1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\nInlet V-Velocity {}\n".format(D[2][-1, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Inlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
print("\nInlet V-Velocity {}\n".format(D[2][-1, ite1-1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\nInlet V-Velocity {}\n".format(D[2][-1, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
if(D[0][-1, ite]==-1):
ite1=ite+1
while ite1<nx+1:
if(D[0][-1, ite1]!=-1):
print("\n[Outlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
print("\nOutlet Pressure {}\n".format(D[3][-1, ite1-1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][-1, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Outlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
print("\nOutlet Pressure {}\n".format(D[3][-1, ite1-1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][-1, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
ite=ite+1
flag = input("\nFinished with South Boundary Condition ?? [y/n]\n")
if(flag=='y'):
flag_SouthBoundary = 1
print("\n--------------------------------------------------\n")
boundary_info.write("\n--------------------------------------------------\n")
# Northern Boundary Defining Loop
while (flag_NorthBoundary < 1):
flag_Inlet_NorthBoundary = 0
flag_Outlet_NorthBoundary = 0
flag_SlidingWall_NorthBoundary = 0
flag = input("\nInlet in North Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Inlet_NorthBoundary = 1
flag = input("\nSliding Wall in North Boundary ?? [y/n]\n")
if(flag=='y'):
flag_SlidingWall_NorthBoundary = 1
flag = input("\nOutlet in North Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Outlet_NorthBoundary = 1
# Initialising Boundary Markers
north_Boundary = np.zeros((3, 6))
north_Boundary[1, 0] = 1
north_Boundary[2, 0] = -1
# Temporary Wall
north_Boundary[0, 1] = xMin
north_Boundary[0, 2] = xMax
D[0][0, :] = 0
D[1][0, :] = 0
D[2][0, :] = 0
# North Boundary Sliding U-velocity
if(flag_SlidingWall_NorthBoundary==1):
north_Boundary[0, 3] = float(input("\nEnter U-Velocity for Sliding Wall in North Boundary\n"))
D[1][0, 1:nx] = north_Boundary[0, 3]
# Inlet definition in North Boundary
if(flag_Inlet_NorthBoundary==1):
north_Boundary[1, 1] = float(input("\nEnter xmin for Inlet in North Boundary\n"))
northInlet_min_index = int((north_Boundary[1, 1]-xMin)/dx)
if(northInlet_min_index==0):
northInlet_min_index+=1
north_Boundary[1, 2] = float(input("\nEnter xmax for Inlet in North Boundary\n"))
northInlet_max_index = int((north_Boundary[1, 2]-xMin)/dx)
if(northInlet_max_index==nx):
northInlet_max_index-=1
north_Boundary[1, 4] = float(input("\nEnter V-Velocity for Inlet in North Boundary\n"))
# Boundary Marker
D[0][0, northInlet_min_index:northInlet_max_index+1] = 1.0
# U-vel Initialised to 0
D[1][0, northInlet_min_index:northInlet_max_index+1] = 0.0
# V-vel User Initialised
D[2][0, northInlet_min_index:northInlet_max_index+1] = north_Boundary[1, 4]
# Outlet definition in North Boundary
if(flag_Outlet_NorthBoundary==1):
flag_Outlet = 1
north_Boundary[2, 1] = float(input("\nEnter xmin for Outlet in North Boundary\n"))
northOutlet_min_index = int((north_Boundary[2, 1]-xMin)/dx)
if(northOutlet_min_index==0):
northOutlet_min_index+=1
north_Boundary[2, 2] = float(input("\nEnter xmax for Outlet in North Boundary\n"))
northOutlet_max_index = int((north_Boundary[2, 2]-xMin)/dx)
if(northOutlet_max_index==nx):
northOutlet_max_index-=1
north_Boundary[2, 5] = float(input("\nEnter Pressure for Outlet in North Boundary\n"))
# Boundary Marker
D[0][0, northOutlet_min_index:northOutlet_max_index+1] = -1.0
# U-vel Uninitialised
D[1][0, northOutlet_min_index:northOutlet_max_index+1] = -1000.5
# V-vel Uninitialised
D[2][0, northOutlet_min_index:northOutlet_max_index+1] = -1000.5
# Pressure User Initialised
D[3][0, northOutlet_min_index:northOutlet_max_index+1] = north_Boundary[2, 5]
print("\n\n------------------NORTH BOUNDARY------------------\n")
boundary_info.write("\n\n------------------NORTH BOUNDARY------------------\n")
ite=0
while ite<nx+1:
if(D[0][0, ite]==0):
ite1=ite+1
if(ite1==nx+1 and D[0][0, ite-1]!=0):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
while ite1<nx+1:
if(D[0][0, ite1]!=0):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
if(flag_SlidingWall_NorthBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[1][0, ite1-1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[1][0, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Wall]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
if(flag_SlidingWall_NorthBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[1][0, ite1-1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[1][0, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
if(D[0][0, ite]==1):
ite1 = ite+1
while ite1<nx+1:
if(D[0][0, ite1]!=1):
print("\n[Inlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
print("\nInlet V-Velocity {}\n".format(D[2][0, ite1-1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\nInlet V-Velocity {}\n".format(D[2][0, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Inlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
print("\nInlet V-Velocity {}\n".format(D[2][0, ite1-1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\nInlet V-Velocity {}\n".format(D[2][0, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
if(D[0][0, ite]==-1):
ite1=ite+1
while ite1<nx+1:
if(D[0][0, ite1]!=-1):
print("\n[Outlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
print("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
print("\nOutlet Pressure {}\n".format(D[3][0, ite1-1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1-1)*dx, ite1-1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-1-ite+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][0, ite1-1]))
ite=ite1-1
break
if(ite1==nx):
print("\n[Outlet]\n")
print("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
print("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
print("\nNo. of elements = [{}] \n".format(ite1-ite+1))
print("\nOutlet Pressure {}\n".format(D[3][0, ite1-1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nxMin = [{}] Starting Index = [{}]\n ".format(xMin+ite*dx, ite))
boundary_info.write("\nxMax = [{}] Ending Index = [{}]\n ".format(xMin+(ite1)*dx, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite1-ite+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][0, ite1-1]))
ite=ite1-1
break
ite1=ite1+1
ite=ite+1
flag = input("\nFinished with North Boundary Condition ?? [y/n]\n")
if(flag=='y'):
flag_NorthBoundary = 1
print("\n--------------------------------------------------\n")
boundary_info.write("\n--------------------------------------------------\n")
# Western Boundary Defining Loop
while (flag_WestBoundary < 1):
flag_Inlet_WestBoundary = 0
flag_Outlet_WestBoundary = 0
flag_SlidingWall_WestBoundary = 0
flag = input("\nInlet in West Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Inlet_WestBoundary = 1
flag = input("\nSliding Wall in West Boundary ?? [y/n]\n")
if(flag=='y'):
flag_SlidingWall_WestBoundary = 1
flag = input("\nOutlet in West Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Outlet_WestBoundary = 1
# Initialising Boundary Markers
west_Boundary = np.zeros((3, 6))
west_Boundary[1, 0] = 1
west_Boundary[2, 0] = -1
# Temporary Wall
west_Boundary[0, 1] = yMin
west_Boundary[0, 2] = yMax
D[0][:, 0] = 0
D[1][:, 0] = 0
D[2][:, 0] = 0
# West Boundary Sliding U-velocity
if(flag_SlidingWall_WestBoundary==1):
west_Boundary[0, 4] = float(input("\nEnter V-Velocity for Sliding Wall in West Boundary\n"))
D[2][1:ny, 0] = west_Boundary[0, 4]
# Inlet definition in West Boundary
if(flag_Inlet_WestBoundary==1):
west_Boundary[1, 1] = float(input("\nEnter ymin for Inlet in West Boundary\n"))
westInlet_bottom_index = int((yMax-west_Boundary[1, 1])/dy)
if(westInlet_bottom_index==ny):
westInlet_bottom_index-=1
west_Boundary[1, 2] = float(input("\nEnter ymax for Inlet in West Boundary\n"))
westInlet_top_index = int((yMax-west_Boundary[1, 2])/dy)
if(westInlet_top_index==0):
westInlet_top_index+=1
west_Boundary[1, 3] = float(input("\nEnter U-Velocity for Inlet in West Boundary\n"))
# Boundary Marker
D[0][westInlet_top_index:westInlet_bottom_index+1, 0] = 1.0
# U-vel User Initialised
D[1][westInlet_top_index:westInlet_bottom_index+1, 0] = west_Boundary[1, 3]
# V-vel Initialised to 0
D[2][westInlet_top_index:westInlet_bottom_index+1, 0] = 0.0
# Outlet definition in West Boundary
if(flag_Outlet_WestBoundary==1):
flag_Outlet = 1
west_Boundary[2, 1] = float(input("\nEnter ymin for Outlet in West Boundary\n"))
westOutlet_bottom_index = int((yMax-west_Boundary[2, 1])/dy)
if(westOutlet_bottom_index==ny):
westOutlet_bottom_index-=1
west_Boundary[2, 2] = float(input("\nEnter ymax for Outlet in West Boundary\n"))
westOutlet_top_index = int((yMax-west_Boundary[2, 2])/dy)
if(westOutlet_top_index==0):
westOutlet_top_index+=1
west_Boundary[2, 5] = float(input("\nEnter Pressure for Outlet in West Boundary\n"))
# Boundary Marker
D[0][westOutlet_top_index:westOutlet_bottom_index+1, 0] = -1.0
# U-vel Uninitialised
D[1][westOutlet_top_index:westOutlet_bottom_index+1, 0] = -1000.5
# V-vel Uninitialised
D[2][westOutlet_top_index:westOutlet_bottom_index+1, 0] = -1000.5
# Pressure User Initialised
D[3][westOutlet_top_index:westOutlet_bottom_index+1, 0] = west_Boundary[2, 5]
print("\n\n------------------WEST BOUNDARY-----------------\n")
boundary_info.write("\n\n------------------WEST BOUNDARY-----------------\n")
ite=ny
while ite>-1:
if(D[0][ite, 0]==0):
ite1=ite-1
if(ite1==-1 and D[0][ite+1, 0]!=0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
while ite1>-1:
if(D[0][ite1, 0]!=0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
if(flag_SlidingWall_WestBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, 0]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, 0]))
ite=ite1+1
break
if(ite1==0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}] \n".format(ite-ite1+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1+1))
if(flag_SlidingWall_WestBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, 0]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, 0]))
ite=ite1+1
break
ite1=ite1-1
if(D[0][ite, 0]==1):
ite1 = ite-1
while ite1>-1:
if(D[0][ite1, 0]!=1):
print("\n[Inlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
print("\nInlet U-Velocity {}\n".format(D[1][ite1+1, 0]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\nInlet U-Velocity {}\n".format(D[1][ite1+1, 0]))
ite=ite1+1
break
if(ite1==0):
print("\n[Inlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}] \n".format(ite-ite1+1))
print("\nInlet U-Velocity {}\n".format(D[1][ite1+1, 0]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1+1))
boundary_info.write("\nInlet U-Velocity {}\n".format(D[1][ite1+1, 0]))
ite=ite1+1
break
ite1=ite1-1
if(D[0][ite, 0]==-1):
ite1=ite-1
while ite1>-1:
if(D[0][ite1, 0]!=-1):
print("\n[Outlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
print("\nOutlet Pressure {}\n".format(D[3][ite1+1, 0]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][ite1+1, 0]))
ite=ite1+1
break
if(ite1==0):
print("\n[Outlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}] \n".format(ite-ite1+1))
print("\nOutlet Pressure {}\n".format(D[3][ite1+1, 0]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][ite1+1, 0]))
ite=ite1+1
break
ite1=ite1-1
ite=ite-1
flag = input("\nFinished with West Boundary Condition ?? [y/n]\n")
if(flag=='y'):
flag_WestBoundary = 1
print("\n-------------------------------------------------\n")
boundary_info.write("\n-------------------------------------------------\n")
# Eastern Boundary Defining Loop
while (flag_EastBoundary < 1):
flag_Inlet_EastBoundary = 0
flag_Outlet_EastBoundary = 0
flag_SlidingWall_EastBoundary = 0
flag = input("\nInlet in East Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Inlet_EastBoundary = 1
flag = input("\nSliding Wall in East Boundary ?? [y/n]\n")
if(flag=='y'):
flag_SlidingWall_EastBoundary = 1
flag = input("\nOutlet in East Boundary ?? [y/n]\n")
if(flag=='y'):
flag_Outlet_EastBoundary = 1
# Initialising Boundary Markers
east_Boundary = np.zeros((3, 6))
east_Boundary[1, 0] = 1
east_Boundary[2, 0] = -1
# Temporary Wall
east_Boundary[0, 1] = yMin
east_Boundary[0, 2] = yMax
D[0][:, -1] = 0
D[1][:, -1] = 0
D[2][:, -1] = 0
# East Boundary Sliding U-velocity
if(flag_SlidingWall_EastBoundary==1):
east_Boundary[0, 4] = float(input("Enter V-Velocity for Sliding Wall in East Boundary\n"))
D[2][1:ny, -1] = east_Boundary[0, 4]
# Inlet definition in East Boundary
if(flag_Inlet_EastBoundary==1):
east_Boundary[1, 1] = float(input("Enter ymin for Inlet in East Boundary\n"))
eastInlet_bottom_index = int((yMax-east_Boundary[1, 1])/dy)
if(eastInlet_bottom_index==ny):
eastInlet_bottom_index-=1
east_Boundary[1, 2] = float(input("Enter ymax for Inlet in East Boundary\n"))
eastInlet_top_index = int((yMax-east_Boundary[1, 2])/dy)
if(eastInlet_top_index==0):
eastInlet_top_index+=1
east_Boundary[1, 3] = float(input("Enter U-Velocity for Inlet in East Boundary\n"))
# Boundary Marker
D[0][eastInlet_top_index:eastInlet_bottom_index+1, -1] = 1.0
# U-vel User Initialised
D[1][eastInlet_top_index:eastInlet_bottom_index+1, -1] = east_Boundary[1, 3]
# V-vel Initialised to 0
D[2][eastInlet_top_index:eastInlet_bottom_index+1, -1] = 0.0
# Outlet definition in East Boundary
if(flag_Outlet_EastBoundary==1):
flag_Outlet = 1
east_Boundary[2, 1] = float(input("Enter ymin for Outlet in East Boundary\n"))
eastOutlet_bottom_index = int((yMax-east_Boundary[2, 1])/dy)
if(eastOutlet_bottom_index==ny):
eastOutlet_bottom_index-=1
east_Boundary[2, 2] = float(input("Enter ymax for Outlet in East Boundary\n"))
eastOutlet_top_index = int((yMax-east_Boundary[2, 2])/dy)
if(eastOutlet_top_index==0):
eastOutlet_top_index+=1
east_Boundary[2, 5] = float(input("Enter Pressure for Outlet in East Boundary\n"))
# Boundary Marker
D[0][eastOutlet_top_index:eastOutlet_bottom_index+1, -1] = -1.0
# U-vel Uninitialised
D[1][eastOutlet_top_index:eastOutlet_bottom_index+1, -1] = -1000.5
# V-vel Uninitialised
D[2][eastOutlet_top_index:eastOutlet_bottom_index+1, -1] = -1000.5
# Pressure User Initialised
D[3][eastOutlet_top_index:eastOutlet_bottom_index+1, -1] = east_Boundary[2, 5]
print("\n\n------------------EAST BOUNDARY-----------------\n")
boundary_info.write("\n\n------------------EAST BOUNDARY-----------------\n")
ite=ny
while ite>-1:
if(D[0][ite, -1]==0):
ite1=ite-1
if(ite1==-1 and D[0][ite+1, -1]!=0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
while ite1>-1:
if(D[0][ite1, -1]!=0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}]\n".format(ite-ite1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}]\n".format(ite-ite1))
if(flag_SlidingWall_EastBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, -1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, -1]))
ite=ite1+1
break
if(ite1==0):
print("\n[Wall]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}]\n".format(ite-ite1+1))
boundary_info.write("\n[Wall]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}]\n".format(ite-ite1+1))
if(flag_SlidingWall_EastBoundary==1):
print("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, -1]))
boundary_info.write("\nSliding Wall Velocity {}\n".format(D[2][ite1+1, -1]))
ite=ite1+1
break
ite1=ite1-1
if(D[0][ite, -1]==1):
ite1 = ite-1
while ite1>-1:
if(D[0][ite1, -1]!=1):
print("\n[Inlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
print("\nInlet U-Velocity {}\n".format(D[1][ite1+1, -1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\nInlet U-Velocity {}\n".format(D[1][ite1+1, -1]))
ite=ite1+1
break
if(ite1==0):
print("\n[Inlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}] \n".format(ite-ite1+1))
print("\nInlet U-Velocity {}\n".format(D[1][ite1+1, -1]))
boundary_info.write("\n[Inlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1+1))
boundary_info.write("\nInlet U-Velocity {}\n".format(D[1][ite1+1, -1]))
ite=ite1+1
break
ite1=ite1-1
if(D[0][ite, -1]==-1):
ite1=ite-1
while ite1>-1:
if(D[0][ite1, -1]!=-1):
print("\n[Outlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
print("\nNo. of elements = [{}] \n".format(ite-ite1))
print("\nOutlet Pressure {}\n".format(D[3][ite1+1, -1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1+1)*dy, ite1+1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][ite1+1, -1]))
ite=ite1+1
break
if(ite1==0):
print("\n[Outlet]\n")
print("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
print("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
print("\nNo. of elements = [{}] \n".format(ite-ite1+1))
print("\nOutlet Pressure {}\n".format(D[3][ite1+1, -1]))
boundary_info.write("\n[Outlet]\n")
boundary_info.write("\nyMin = [{:.2f}] Bottom Index = [{}]\n ".format(yMax-(ite)*dy, ite))
boundary_info.write("\nyMax = [{:.2f}] Top Index = [{}]\n ".format(yMax-(ite1)*dy, ite1))
boundary_info.write("\nNo. of elements = [{}] \n".format(ite-ite1+1))
boundary_info.write("\nOutlet Pressure {}\n".format(D[3][ite1+1, -1]))
ite=ite1+1
break
ite1=ite1-1
ite=ite-1
flag = input("Finished with East Boundary Condition ?? [y/n]")
if(flag=='y'):
flag_EastBoundary = 1
print("\n-------------------------------------------------\n")
boundary_info.write("\n-------------------------------------------------\n")
flag_Boundary = 1
return D, xMin, xMax, yMin, yMax, dx, dy, nx, ny, south_Boundary, north_Boundary, west_Boundary, east_Boundary, flag_Outlet
def obstacle(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy):
package_dir = os.path.dirname(os.path.realpath(__file__))
flag_obstacle = 'n'
while flag_obstacle!='y':
scal_x = float(input("\nEnter Scaling factor for X-direction\n"))
scal_y = float(input("\nEnter Scaling factor for Y-direction\n"))
traf_x = float(input("\nOffset in X\n"))
traf_y = float(input("\nOffset in Y\n")) + dy/10
rot = float(input("\nEnter anti-clockwise rotation angle\n"))
flag_geometryCase = input("\n1. Enter address of .txt file\n2. Use default address\n")
if(flag_geometryCase==1):
geometryCase = input("\nEnter address of .txt file\nExample: /home/user/folder/Case_1/Points.txt\n")
else:
geometryCase = package_dir+"/Points.txt"
file1 = open(geometryCase, 'r')
Lines = file1.readlines()
P=[]
N=0
for line in Lines:
N+=1
P.append(np.fromstring(line.strip(), dtype=float, sep=' '))
N+=1
P.append(np.fromstring(Lines[0].strip(), dtype=float, sep=' '))
Lx = xMax-xMin
Ly = yMax-yMin
Points_x=[]
Points_y=[]
for i in range (0, N):
Points_x.append(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan((P[i][1])/(P[i][0])))+traf_x)
Points_y.append(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0]))+traf_y)
fig = plt.subplots(figsize =(Lx*5, Ly*5))
plt.xlim(xMin, xMax)
plt.ylim(yMin, yMax)
plt.fill(Points_x, Points_y, color = 'black')
plt.show()
flag_obstacle = (input("\nConitnue [Y/N] ??\n"))
if(flag_obstacle!='y'):
continue
for i in range(0, ny+1):
for j in range (0, nx+1):
X = xMin + j*dx
Y = yMax - i*dy
count=0
for ite in range (0, N-1):
X1 = Points_x[ite]
X2 = Points_x[ite+1]
Y1 = Points_y[ite]
Y2 = Points_y[ite+1]
if(Y1<=Y<=Y2 or Y2<=Y<=Y1):
if(X1<=X2):
if(X<=(X2+(Y-Y2)*(X1-X2)/(Y1-Y2))):
count +=1
if(X2<=X1):
if(X<=(X1+(Y-Y1)*(X2-X1)/(Y2-Y1))):
count +=1
if(count==1):
D[0][i, j] = 0
D[1][i, j] = 0
D[2][i, j] = 0
D[3][i, j] = -100000
return D, P, Points_x, Points_y
def obstacleMath(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy):
flag_obstacle = 'n'
while flag_obstacle!='y':
scal_x = float(input("\nEnter Scaling factor for X-direction\n"))
scal_y = float(input("\nEnter Scaling factor for Y-direction\n"))
traf_x = float(input("\nOffset in X\n"))
traf_y = float(input("\nOffset in Y\n")) + dy/10
rot = int(input("\nEnter anti-clockwise rotation angle\n"))
P=[]
asq = float(input("\nEnter Horizontal axis length for Elliptical Geometry\n"))
bsq = float(input("\nEnter Vertical axis length for Elliptical Geometry\n"))
a=asq**2
b=bsq**2
N=0
for theta in range (0, 360):
if(theta%2==0):
temp1=a*b/(b+a*np.tan(theta*np.pi/180)**2)
if(0<=theta<=90):
temp = [np.abs(np.sqrt(temp1)), np.abs(np.tan(theta*np.pi/180))*(np.abs(np.sqrt(temp1)))]
elif(90<=theta<=180):
temp = [-np.abs(np.sqrt(temp1)), np.abs(np.tan(theta*np.pi/180))*(np.abs(np.sqrt(temp1)))]
elif(180<=theta<=270):
temp = [-np.abs(np.sqrt(temp1)), -np.abs(np.tan(theta*np.pi/180))*(np.abs(np.sqrt(temp1)))]
elif(270<=theta<=360):
temp = [np.abs(np.sqrt(temp1)), -np.abs(np.tan(theta*np.pi/180))*(np.abs(np.sqrt(temp1)))]
P.append(temp)
N+=1
P.append(P[0])
Lx = xMax-xMin
Ly = yMax-yMin
Points_x=[]
Points_y=[]
for i in range(0, 181):
if(0<=(i+rot/2)<=45):
Points_x.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(45<=(i+rot/2)<=90):
Points_x.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(90<=(i+rot/2)<=135):
Points_x.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(135<=(i+rot/2)<=180):
Points_x.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(180<=(i+rot/2)<=225):
Points_x.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(-45<=(i+rot/2)<=0):
Points_x.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(-90<=(i+rot/2)<=-45):
Points_x.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(-135<=(i+rot/2)<=-90):
Points_x.append(-np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
elif(-180<=(i+rot/2)<=-135):
Points_x.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.cos(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_x)
Points_y.append(np.abs(np.sqrt((P[i][0]*scal_x)**2 + (P[i][1]*scal_y)**2)*np.sin(rot*np.pi/180+np.arctan(P[i][1]/P[i][0])))+traf_y)
fig = plt.subplots(figsize =(Lx*5, Ly*5))
plt.xlim(xMin, xMax)
plt.ylim(yMin, yMax)
plt.fill(Points_x, Points_y, color='black')
plt.show()
flag_obstacle = (input("\nConitnue [Y/N] ??\n"))
if(flag_obstacle!='y'):
continue
for i in range(0, ny+1):
for j in range (0, nx+1):
X = xMin + j*dx
Y = yMax - i*dy
count=0
for ite in range (0, 180):
X1 = Points_x[ite]
X2 = Points_x[ite+1]
Y1 = Points_y[ite]
Y2 = Points_y[ite+1]
if(Y1<Y<=Y2 or Y2<=Y<Y1):
if(X<=X1 or X<=X2):
count +=1
if(count==1):
D[0][i, j] = 0
D[1][i, j] = 0
D[2][i, j] = 0
D[3][i, j] = -100000
return D, P, Points_x, Points_y | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/boundaryDomain.py | boundaryDomain.py |
import numpy as np
def U_coeffUpwind(Uxo, Uyo, Po, Uue, Uuw, Vun, Vus, D, rho, visc, urf_UV, nx, ny, dx, dy):
Aup = np.zeros((ny, nx+1))
Aue = np.zeros((ny, nx+1))
Auw = np.zeros((ny, nx+1))
Aun = np.zeros((ny, nx+1))
Aus = np.zeros((ny, nx+1))
Bup = np.zeros((ny, nx+1))
vyx = visc*dy/dx
vxy = visc*dx/dy
for i in range (0, ny):
for j in range (0, nx+1):
if(j!=0 and j!=nx):
Aup[i, j] = rho*dy*(max(Uue[i, j], 0) + max(-Uuw[i, j], 0)) +\
rho*dx*(max(Vun[i, j], 0) + max(-Vus[i, j], 0)) +\
2*(vyx+vxy)
Aue[i, j] = rho*dy*max(-Uue[i, j], 0) + vyx
Auw[i, j] = rho*dy*max(Uuw[i, j], 0) + vyx
Aun[i, j] = rho*dx*max(-Vun[i, j], 0) + vxy
Aus[i, j] = rho*dx*max(Vus[i, j], 0) + vxy
Bup[i, j] = dy*(Po[i, j-1]-Po[i, j])
# South Boundary Outlet
if(D[0][i, j] == 2 and D[0][i+1, j] == -1):
Aup[i, j] += -vxy - rho*dx*max(Vus[i, j], 0)
Aus[i, j] = 0
# North Boundary Outlet
if(D[0][i, j] == -1 and D[0][i+1, j] == 2):
Aup[i, j] += -vxy - rho*dx*max(-Vun[i, j], 0)
Aue[i, j] = 0
# South Boundary Wall
if(D[0][i, j] == 2 and D[0][i+1, j] == 0):
Aup[i, j] += 2*vxy
Aun[i, j] += vxy/3
Aus[i, j] = 0
Bup[i, j] += vxy*8*D[1][i+1, j]/3
# North Boundary Wall
if(D[0][i, j] == 0 and D[0][i+1, j] == 2):
Aup[i, j] += 2*vxy
Aus[i, j] += vxy/3
Aun[i, j] = 0
Bup[i, j] += vxy*8*D[1][i, j]/3
# South Boundary Inlet
if(D[0][i, j] == 2 and D[0][i+1, j] == 1):
Aup[i, j] += 2*vxy + 2*rho*dx*max(Vus[i, j], 0)
Aun[i, j] += vxy/3 + rho*dx*max(Vus[i, j], 0)/3
Aus[i, j] = 0
Bup[i, j] += vxy*8*D[1][i+1, j]/3 + 8*rho*dx*D[1][i+1, j]*max(Vus[i, j], 0)/3
# North Boundary Inlet
if(D[0][i, j] == 1 and D[0][i+1, j] == 2):
Aup[i, j] += 2*vxy + 2*rho*dx*max(-Vun[i, j], 0)
Aus[i, j] += vxy/3 + rho*dx*max(-Vun[i, j], 0)/3
Aun[i, j] = 0
Bup[i, j] += vxy*8*D[1][i, j]/3 + 8*rho*dx*D[1][i, j]*max(-Vun[i, j], 0)/3
# Data Point on Boundary
if(D[0][i, j]!=2 and D[0][i+1, j]!=2):
Aup[i, j] = 1
Aue[i, j] = 0
Auw[i, j] = 0
Aun[i, j] = 0
Aus[i, j] = 0
Bup[i, j] = Uxo[i, j]
# Outlet Boundary
if(D[0][i, j]==-1 and D[0][i+1, j]==-1 and j==nx):
Aup[i, j] = 1
Aue[i, j] = 0
Auw[i, j] = 1
Aun[i, j] = 0
Aus[i, j] = 0
Bup[i, j] = 0
if(D[0][i, j]==-1 and D[0][i+1, j]==-1 and j==0):
Aup[i, j] = 1
Aue[i, j] = 1
Auw[i, j] = 0
Aun[i, j] = 0
Aus[i, j] = 0
Bup[i, j] = 0
# Under-Relaxation Factor
if(D[0][i, j]==2 or D[0][i+1, j]==2):
Aup[i, j] = Aup[i, j]/urf_UV
Bup[i, j] += (1-urf_UV)*Aup[i, j]*Uxo[i, j]
# Matrix Creation
M_Bup = Bup.flatten()
M_Au = np.zeros(((ny)*(nx+1), (ny)*(nx+1)))
ite=0
for i in range (0, ny):
for j in range (0, nx+1):
M_Au[ite, ite] = Aup[i, j]
if ((ite+1)%(nx+1)!=0):
M_Au[ite, ite+1] = -Aue[i, j]
if((ite%(nx+1)!=0) and (ite!=0)):
M_Au[ite, ite-1] = -Auw[i, j]
if (ite<(ny-1)*(nx+1)):
M_Au[ite, ite+nx+1] = -Aus[i, j]
if(ite>nx):
M_Au[ite, ite-nx-1] = -Aun[i, j]
ite+=1
return M_Au, M_Bup, Aup, Aue, Auw, Aun, Aus, Bup
def V_coeffUpwind(Uxo, Uyo, Po, Uve, Uvw, Vvn, Vvs, D, rho, visc, urf_UV, nx, ny, dx, dy):
Avp = np.zeros((ny+1, nx))
Ave = np.zeros((ny+1, nx))
Avw = np.zeros((ny+1, nx))
Avn = np.zeros((ny+1, nx))
Avs = np.zeros((ny+1, nx))
Bvp = np.zeros((ny+1, nx))
vyx = visc*dy/dx
vxy = visc*dx/dy
for i in range (0, ny+1):
for j in range (0, nx):
if(i!=0 and i!=ny):
Avp[i, j] = rho*dy*(max(Uve[i, j], 0) + max(-Uvw[i, j], 0)) +\
rho*dx*(max(Vvn[i, j], 0) + max(-Vvs[i, j], 0)) +\
2*(vxy+vyx)
Ave[i, j] = rho*dy*max(-Uve[i, j], 0) + vyx
Avw[i, j] = rho*dy*max(Uvw[i, j], 0) + vyx
Avn[i, j] = rho*dx*max(-Vvn[i, j], 0) + vxy
Avs[i, j] = rho*dx*max(Vvs[i, j], 0) + vxy
Bvp[i, j] = dx*(Po[i, j]-Po[i-1, j])
# West Boundary Outlet
if(D[0][i, j] == -1 and D[0][i, j+1] == 2):
Avp[i, j] += -vyx - rho*dy*max(Uvw[i, j], 0)
Avw[i, j] = 0
# East Boundary Outlet
if(D[0][i, j] == 2 and D[0][i, j+1] == -1):
Avp[i, j] += -vyx - rho*dy*max(-Uve[i, j], 0)
Ave[i, j] = 0
# West Boundary Wall
if(D[0][i, j] == 0 and D[0][i, j+1] == 2):
Avp[i, j] += 2*vyx
Ave[i, j] += vyx/3
Avw[i, j] = 0
Bvp[i, j] += vyx*8*D[2][i, j]/3
# East Boundary Wall
if(D[0][i, j] == 2 and D[0][i, j+1] == 0):
Avp[i, j] += 2*vyx
Avw[i, j] += vyx/3
Ave[i, j] = 0
Bvp[i, j] += vyx*8*D[2][i, j+1]/3
# West Boundary Inlet
if(D[0][i, j] == 1 and D[0][i, j+1] == 2):
Avp[i, j] += 2*vyx + 2*rho*dy*max(Uvw[i, j], 0)
Ave[i, j] += vyx/3 + rho*dy*max(Uvw[i, j], 0)/3
Avw[i, j] = 0
Bvp[i, j] += vyx*8*D[2][i, j]/3 + 8*rho*dy*D[2][i, j]*max(Uvw[i, j], 0)/3
# East Boundary Inlet
if(D[0][i, j] == 2 and D[0][i, j+1] == 1):
Avp[i, j] += 2*vyx + 2*rho*dy*max(-Uve[i, j], 0)
Avw[i, j] += vyx/3 + rho*dy*max(-Uve[i, j], 0)/3
Ave[i, j] = 0
Bvp[i, j] += vyx*8*D[2][i, j+1]/3 + 8*rho*dy*D[2][i, j+1]*max(-Uve[i, j], 0)/3
# Data Point on Boundary
if(D[0][i, j]!=2 and D[0][i, j+1]!=2):
Avp[i, j] = 1
Ave[i, j] = 0
Avw[i, j] = 0
Avn[i, j] = 0
Avs[i, j] = 0
Bvp[i, j] = Uyo[i, j]
# Outlet Boundary
if(D[0][i, j]==-1 and D[0][i, j+1]==-1 and i==0):
Avp[i, j] = 1
Ave[i, j] = 0
Avw[i, j] = 0
Avn[i, j] = 0
Avs[i, j] = 1
Bvp[i, j] = 0
if(D[0][i, j]==-1 and D[0][i, j+1]==-1 and i==ny):
Avp[i, j] = 1
Ave[i, j] = 0
Avw[i, j] = 0
Avn[i, j] = 1
Avs[i, j] = 0
Bvp[i, j] = 0
# Under-Relaxation Factor
if(D[0][i, j]==2 or D[0][i, j+1]==2):
Avp[i, j] = Avp[i, j]/urf_UV
Bvp[i, j] += (1-urf_UV)*Avp[i, j]*Uyo[i, j]
# Matrix Creation
M_Bvp = Bvp.flatten()
M_Av = np.zeros(((ny+1)*(nx), (ny+1)*(nx)))
ite=0
for i in range (0, ny+1):
for j in range (0, nx):
M_Av[ite, ite] = Avp[i, j]
if ((ite+1)%(nx)!=0):
M_Av[ite, ite+1] = -Ave[i, j]
if((ite%(nx)!=0) and (ite!=0)):
M_Av[ite, ite-1] = -Avw[i, j]
if (ite<(ny)*(nx)):
M_Av[ite, ite+nx] = -Avs[i, j]
if(ite>nx-1):
M_Av[ite, ite-nx] = -Avn[i, j]
ite+=1
return M_Av, M_Bvp, Avp, Ave, Avw, Avn, Avs, Bvp | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/UV_coeff.py | UV_coeff.py |
#%%
import numpy as np
import matplotlib as mpl
from matplotlib import cm
from matplotlib import pyplot as plt
from scipy import linalg
import sys, os
mpl.rcParams.update({'font.size': 15})
caseFolder = input("\nEnter address of testCase ...\nExample: /home/user/folder/Case_1\n")
try:
os.mkdir(caseFolder)
except:
print("\nFolder already there!!\n")
flag_EmptyFolder = input("\nEmpty Folder ?? [y/n]\n")
if(flag_EmptyFolder=='y'):
filelist = [ f for f in os.listdir(caseFolder) ]
for f in filelist:
os.remove(os.path.join(caseFolder, f))
else:
sys.exit()
package_dir = os.path.dirname(os.path.realpath(__file__))
print(package_dir)
from RUN_package.boundaryDomain import domain, obstacle, obstacleMath
from RUN_package.initialConditions import initialCond
from RUN_package.faceInterpolation import U_face, V_face
from RUN_package.UV_coeff import U_coeffUpwind, V_coeffUpwind
from RUN_package.P_coeff import P_coeffSIMPLE
from RUN_package.correction import correctionSIMPLE
from RUN_package.postProcessing import postProcessor
D, \
xMin, xMax, yMin, yMax, \
dx, dy, nx, ny, \
south_Boundary, north_Boundary, west_Boundary, east_Boundary, \
flag_Outlet =\
domain(caseFolder)
flag_obstacleGeometry = int(input("\n1. Use .txt file as Address \n2. Add elliptical obstacle\n3. No Obstacle Geometry\n"))
if(flag_obstacleGeometry==1):
D, Points, Points_x, Points_y = obstacle(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy)
elif(flag_obstacleGeometry==2):
D, Points, Points_x, Points_y = obstacleMath(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy)
Lx = xMax-xMin
Ly = yMax-yMin
# Grid - Plot
xg = np.linspace(xMin, xMax, num=nx+2)
yg = np.linspace(yMax, yMin, num=ny+2)
Xg, Yg = np.meshgrid(xg, yg)
fig, ax = plt.subplots(figsize =(Lx*6*1.4, Ly*6))
plt.xlabel('x [m]')
plt.ylabel('y [m]')
cmap = plt.get_cmap('tab10')
ylorbr = cm.get_cmap('tab10', 4)
norm = mpl.colors.Normalize(vmin=-1.5, vmax=2.5)
col = plt.pcolormesh(xg, yg, D[0], cmap = ylorbr, norm=norm)
cbar = plt.colorbar(col)
cbar.set_label('Grid\n-1.0 - Outlet 0.0 - Wall 1.0 - Inlet 2.0 - Wall')
plt.axis('scaled')
# show plot
plt.show()
flag_continue = input("\nContinue or Abort ?? [y/n]\n")
if(flag_continue=='n'):
sys.exit()
urf_UV = float(input("\nEnter Under-relaxation factor for UV\n"))
urf_P = float(input("\nEnter Under-relaxation factor for P\n"))
rho = float(input("\nEnter Density of fluid [kg/m^3]\n"))
visc = float(input("\nEnter Viscosity of Fluid [Pa*s]\n"))
max_iter = int(input("\nEnter Max Iteration for this SIM\n"))
MaxRes_Mass = float(input("\nEnter Min Mass Imbalance Residual for this SIM\n"))
Uxo, Uyo, Po = initialCond(D, nx, ny, flag_Outlet)
Ux_values=[]
Ux_values.append(Uxo)
Uy_values=[]
Uy_values.append(Uyo)
P_values=[]
P_values.append(Po)
Res_U_values=[]
Res_V_values=[]
Res_Mass_values=[]
logRes_Mass=0.0
n=0
iter_ = np.linspace(0, max_iter, max_iter)
temp = np.linspace(0, max_iter, max_iter)
fig, ax = plt.subplots(figsize =(Lx*6*1.4, Ly*6))
plt.xlabel('x [m]')
plt.ylabel('y [m]')
while n<max_iter and logRes_Mass>MaxRes_Mass:
Uue, Uuw, Vun, Vus = U_face(Uxo, Uyo, D, nx, ny)
Uve, Uvw, Vvn, Vvs = V_face(Uxo, Uyo, D, nx, ny)
M_Au, M_Bup, Aup, Aue, Auw, Aun, Aus, Bup = \
U_coeffUpwind(Uxo, Uyo, Po, Uue, Uuw, Vun, Vus, D, rho, visc, urf_UV, nx, ny, dx, dy)
M_Av, M_Bvp, Avp, Ave, Avw, Avn, Avs, Bvp = \
V_coeffUpwind(Uxo, Uyo, Po, Uve, Uvw, Vvn, Vvs, D, rho, visc, urf_UV, nx, ny, dx, dy)
# Momentum Predictor
M_Uxs = linalg.solve(M_Au, M_Bup)
M_Uys = linalg.solve(M_Av, M_Bvp)
Uxs = np.reshape(M_Uxs, (ny, nx+1))
Uys = np.reshape(M_Uys, (ny+1, nx))
M_Ap, M_Bpp, App, Ape, Apw, Apn, Aps, Bpp = P_coeffSIMPLE(Aup, Avp, Uxs, Uys, D, nx, ny, dx, dy)
if(flag_Outlet==0):
M_Ap[int(ny*nx/4), :] = 0
M_Ap[int(ny*nx/4), int(ny*nx/4)] = 1
M_Bpp[int(ny*nx/4)] = 0
# Pressure Correction values
M_Pc = linalg.solve(M_Ap, M_Bpp)
Pc = np.reshape(M_Pc, (ny, nx))
# Residuals
Res_U = M_Au.dot(Uxo.flatten())-M_Bup
Res_V = M_Av.dot(Uyo.flatten())-M_Bvp
logRes_U = np.log(np.sum(np.abs(Res_U)))
logRes_V = np.log(np.sum(np.abs(Res_V)))
logRes_Mass = np.log(np.sum(np.abs(Bpp)))
# Momentum & Pressure Correction step
Ux, Uy, P = correctionSIMPLE(Uxs, Uys, Po, Pc, D, Aup, Avp, urf_UV, urf_P, nx, ny, dx, dy)
# Writing Results
Ux_values.append(Ux.copy())
Uy_values.append(Uy.copy())
P_values.append(P.copy())
Res_U_values.append(logRes_U)
Res_V_values.append(logRes_V)
Res_Mass_values.append(logRes_Mass)
# Prepping for next step
Uxo = Ux.copy()
Uyo = Uy.copy()
Po = P.copy()
iter_ = np.linspace(0, n+1, n+1)
ax.set_xlim(-0.5, n+2)
max_Res=0
min_Res=0
for k in range (0, n+1):
if(max_Res<Res_U_values[k]):
max_Res=Res_U_values[k]
if(max_Res<Res_V_values[k]):
max_Res=Res_U_values[k]
if(max_Res<Res_Mass_values[k]):
max_Res=Res_Mass_values[k]
if(min_Res>Res_U_values[k]):
min_Res=Res_U_values[k]
if(min_Res>Res_V_values[k]):
min_Res=Res_U_values[k]
if(min_Res>Res_Mass_values[k]):
min_Res=Res_Mass_values[k]
ax.set_ylim(min_Res-1, max_Res+1)
plt.plot(iter_, Res_U_values, color='red', label='Ux-Mom Residual')
plt.plot(iter_, Res_V_values, color='blue', label='Uy-Mom Residual')
plt.plot(iter_, Res_Mass_values, color='green', label='Mass Residual')
plt.legend()
plt.show()
n+=1
if(n<max_iter):
max_iter=n
max_iter
uxq_values = []
uyq_values = []
for n in range (0, max_iter):
ux1 = Ux_values[n].copy()
uxq = np.zeros((2*ny+1, 2*nx+1))
for i in range (0, ny):
for j in range (0, nx+1):
uxq[2*i+1, 2*j] = ux1[i, j]
for j in range (0, nx+1):
uxq[0, 2*j] = D[1][0, j]
uxq[-1, 2*j] = D[1][-1, j]
for i in range (0, ny-1):
for j in range (0, nx+1):
uxq[2*i+2, 2*j] = (uxq[2*i+1, 2*j] + uxq[2*i+3, 2*j])/2
for i in range (0, 2*ny):
for j in range (0, nx):
uxq[i, 2*j+1] = (uxq[i, 2*j] + uxq[i, 2*j+2])/2
uy1 = Uy_values[n].copy()
uyq = np.zeros((2*ny+1, 2*nx+1))
for i in range (0, ny+1):
for j in range (0, nx):
uyq[2*i, 2*j+1] = uy1[i, j]
for i in range (0, ny+1):
uyq[2*i, 0] = D[2][i, 0]
uyq[2*i, -1] = D[2][i, -1]
for i in range (0, ny+1):
for j in range (0, nx-1):
uyq[2*i, 2*j+2] = (uyq[2*i, 2*j+1] + uyq[2*i, 2*j+3])/2
for i in range (0, ny):
for j in range (0, 2*nx):
uyq[2*i+1, j] = (uyq[2*i, j] + uyq[2*i+2, j])/2
uxq_values.append(uxq)
uyq_values.append(uyq)
#%%
flag_Validation = input("Validation check for Lid-driven Cavity Re-[100, 1000, 5000] ?? [y/n]")
if(flag_Validation=='y'):
mpl.rcParams.update({'font.size': 10})
ghia_u100 = np.array([1, 0.84123, 0.78871, 0.73722, 0.68717, 0.23151, 0.00332, -0.13641, -0.20581, -0.2109, -0.15662, -0.1015, -0.06434, -0.04775, -0.04192, -0.03717, 0])
ghia_u1000 = np.array([1, 0.65928, 0.57492, 0.51117, 0.46604, 0.33304, 0.18719, 0.05702, -0.0608, -0.10648, -0.27805, -0.38289, -0.2973, -0.2222, -0.20196, -0.18109, 0])
ghia_u5000 = np.array([1, 0.48223, 0.4612, 0.45992, 0.46036, 0.33556, 0.20087, 0.08183, -0.03039, -0.07404, -0.22855, -0.3305, -0.40435, -0.43643, -0.42901, -0.41165, 0])
ghia_y = np.array([1, 0.9766, 0.9688, 0.9609, 0.9531, 0.8516, 0.7344, 0.6172, 0.5, 0.4531, 0.2813, 0.1719, 0.1016, 0.0703, 0.0625, 0.0547, 0])
yq = np.linspace(yMax, yMin, num=2*ny+1)
Re = rho*D[1][0, int(nx/2)]*Lx/visc
if(Re==100):
plt.scatter(ghia_u100, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 100 Mesh -[{}X{}]'.format(nx, ny))
if(Re==1000):
plt.scatter(ghia_u1000, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 1000 Mesh -[{}X{}]'.format(nx, ny))
if(Re==5000):
plt.scatter(ghia_u5000, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 5000 Mesh -[{}X{}]'.format(nx, ny))
plt.plot(uxq_values[max_iter-1][:, nx], yq, label ='Centreline X-Velocity')
plt.legend()
plt.show()
flag_Validation = input("Validation check for Fully developed flow ?? [y/n]")
if(flag_Validation=='y'):
mpl.rcParams.update({'font.size': 10})
Re = rho*D[1][int(ny/2), 0]*Ly/visc
yq = np.linspace(yMax, yMin, num=2*ny+1)
plt.plot(uxq_values[max_iter-1][:, int(8*(2*nx+1)/10)], yq, label ='Centreline X-Velocity - at X={}'.format(xMin+int(8*(2*nx+1)/10)*dx/2))
# plt.set_xlabel('Y')
plt.title('Fully Developed Flow Re = {}'.format(Re))
plt.legend()
plt.show()
xq = np.linspace(xMin, xMax, num=2*nx+1)
plt.plot(uxq_values[max_iter-1][ny, :], xq, label ='Centreline X-Velocity - at Y={}'.format(yMax-ny*dy/2))
# plt.set_xlabel('X')
plt.title('Fully Developed Flow Re = {}'.format(Re))
plt.legend()
plt.show()
#%%
postProcessor(P_values, uxq_values, uyq_values, \
xMin, xMax, yMin, yMax, nx, ny, dx, dy, Points_x, Points_y, \
caseFolder, Res_U_values, Res_V_values, Res_Mass_values, \
max_iter, min_Res, max_Res) | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/RUN-spyder.py | RUN-spyder.py |
import numpy as np
def P_coeffSIMPLE(Aup, Avp, Uxs, Uys, D, nx, ny, dx, dy):
App =np.zeros((ny, nx))
Ape =np.zeros((ny, nx))
Apw =np.zeros((ny, nx))
Apn =np.zeros((ny, nx))
Aps =np.zeros((ny, nx))
Bpp =np.zeros((ny, nx))
for j in range (0, nx):
for i in range (0, ny):
if (D[0][i, j+1]!=2 and D[0][i+1, j+1]!=2):
Ape[i, j] = 0
else:
Ape[i, j] = dy**2/Aup[i, j+1]
if (D[0][i, j]!=2 and D[0][i+1, j]!=2):
Apw[i, j] = 0
else:
Apw[i, j] = dy**2/Aup[i, j]
if (D[0][i, j]!=2 and D[0][i, j+1]!=2):
Apn[i, j] = 0
else:
Apn[i, j] = dx**2/Avp[i, j]
if (D[0][i+1, j]!=2 and D[0][i+1, j+1]!=2):
Aps[i, j] = 0
else:
Aps[i, j] = dx**2/Avp[i+1, j]
App[i, j] = Ape[i, j] + Apw[i, j] + Apn[i, j] + Aps[i, j]
Bpp[i, j] = dy*(Uxs[i, j]-Uxs[i, j+1]) + \
dx*(Uys[i+1, j]-Uys[i, j])
if(D[0][i, j]==-1 or D[0][i+1, j]==-1 or D[0][i, j+1]==-1 or D[0][i+1, j+1]==-1):
App[i, j] = 1
Ape[i, j] = 0
Apw[i, j] = 0
Apn[i, j] = 0
Aps[i, j] = 0
Bpp[i, j] = 0
if(D[0][i, j]!=2 and D[0][i+1, j]!=2 and D[0][i, j+1]!=2 and D[0][i+1, j+1]!=2):
App[i, j] = 1
Ape[i, j] = 0
Apw[i, j] = 0
Apn[i, j] = 0
Aps[i, j] = 0
Bpp[i, j] = 0
M_Bpp = Bpp.flatten()
M_A = np.zeros((ny*nx, ny*nx))
ite=0
for i in range (0, ny):
for j in range (0, nx):
M_A[ite, ite] = App[i, j]
if ((ite+1)%(nx)!=0):
M_A[ite, ite+1] = -Ape[i, j]
if(ite%(nx)!=0):
M_A[ite, ite-1] = -Apw[i, j]
if (ite<(ny-1)*(nx)):
M_A[ite, ite+nx] = -Aps[i, j]
if(ite>nx-1):
M_A[ite, ite-nx] = -Apn[i, j]
ite+=1
return M_A, M_Bpp, App, Ape, Apw, Apn, Aps, Bpp | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/P_coeff.py | P_coeff.py |
#%%
import numpy as np
import matplotlib as mpl
from matplotlib import cm
from matplotlib import pyplot as plt
from scipy import linalg
import sys, os
mpl.rcParams.update({'font.size': 15})
caseFolder = input("\nEnter address of testCase ...\nExample: /home/user/folder/Case_1\n")
try:
os.mkdir(caseFolder)
except:
print("\nFolder already there!!\n")
flag_EmptyFolder = input("\nEmpty Folder ?? [y/n]\n")
if(flag_EmptyFolder=='y'):
filelist = [ f for f in os.listdir(caseFolder) ]
for f in filelist:
os.remove(os.path.join(caseFolder, f))
else:
sys.exit()
package_dir = os.path.dirname(os.path.realpath(__file__))
print(package_dir)
from RUN_package.boundaryDomain import domain, obstacle, obstacleMath
from RUN_package.initialConditions import initialCond
from RUN_package.faceInterpolation import U_face, V_face
from RUN_package.UV_coeff import U_coeffUpwind, V_coeffUpwind
from RUN_package.P_coeff import P_coeffSIMPLE
from RUN_package.correction import correctionSIMPLE
from RUN_package.postProcessing import postProcessor
D, \
xMin, xMax, yMin, yMax, \
dx, dy, nx, ny, \
south_Boundary, north_Boundary, west_Boundary, east_Boundary, \
flag_Outlet =\
domain(caseFolder)
flag_obstacleGeometry = int(input("\n1. Use .txt file as Address \n2. Add elliptical obstacle\n3. No Obstacle Geometry\n"))
if(flag_obstacleGeometry==1):
D, Points, Points_x, Points_y = obstacle(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy)
elif(flag_obstacleGeometry==2):
D, Points, Points_x, Points_y = obstacleMath(D, xMin, xMax, yMin, yMax, nx, ny, dx, dy)
Lx = xMax-xMin
Ly = yMax-yMin
# Grid - Plot
xg = np.linspace(xMin, xMax, num=nx+2)
yg = np.linspace(yMax, yMin, num=ny+2)
Xg, Yg = np.meshgrid(xg, yg)
fig, ax = plt.subplots(figsize =(Lx*6*1.4, Ly*6))
plt.xlabel('x [m]')
plt.ylabel('y [m]')
cmap = plt.get_cmap('tab10')
ylorbr = cm.get_cmap('tab10', 4)
norm = mpl.colors.Normalize(vmin=-1.5, vmax=2.5)
col = plt.pcolormesh(xg, yg, D[0], cmap = ylorbr, norm=norm)
cbar = plt.colorbar(col)
cbar.set_label('Grid\n-1.0 - Outlet 0.0 - Wall 1.0 - Inlet 2.0 - Wall')
plt.axis('scaled')
# show plot
plt.show()
flag_continue = input("\nContinue or Abort ?? [y/n]\n")
if(flag_continue=='n'):
sys.exit()
urf_UV = float(input("\nEnter Under-relaxation factor for UV\n"))
urf_P = float(input("\nEnter Under-relaxation factor for P\n"))
rho = float(input("\nEnter Density of fluid [kg/m^3]\n"))
visc = float(input("\nEnter Viscosity of Fluid [Pa*s]\n"))
max_iter = int(input("\nEnter Max Iteration for this SIM\n"))
MaxRes_Mass = float(input("\nEnter Min Mass Imbalance Residual for this SIM\n"))
Uxo, Uyo, Po = initialCond(D, nx, ny, flag_Outlet)
Ux_values=[]
Ux_values.append(Uxo)
Uy_values=[]
Uy_values.append(Uyo)
P_values=[]
P_values.append(Po)
Res_U_values=[]
Res_V_values=[]
Res_Mass_values=[]
logRes_Mass=0.0
n=0
iter_ = np.linspace(0, max_iter, max_iter)
temp = np.linspace(0, max_iter, max_iter)
plt.ion()
fig = plt.figure()
ax = fig.add_subplot(111)
line1, = ax.plot(iter_, temp, color = 'red', label = 'Ux-Mom Residual')
line2, = ax.plot(iter_, temp, color = 'blue', label = 'Uy-Mom Residual')
line3, = ax.plot(iter_, temp, color = 'green', label = 'Mass Residual')
ax.legend()
while n<max_iter and logRes_Mass>MaxRes_Mass:
Uue, Uuw, Vun, Vus = U_face(Uxo, Uyo, D, nx, ny)
Uve, Uvw, Vvn, Vvs = V_face(Uxo, Uyo, D, nx, ny)
M_Au, M_Bup, Aup, Aue, Auw, Aun, Aus, Bup = \
U_coeffUpwind(Uxo, Uyo, Po, Uue, Uuw, Vun, Vus, D, rho, visc, urf_UV, nx, ny, dx, dy)
M_Av, M_Bvp, Avp, Ave, Avw, Avn, Avs, Bvp = \
V_coeffUpwind(Uxo, Uyo, Po, Uve, Uvw, Vvn, Vvs, D, rho, visc, urf_UV, nx, ny, dx, dy)
# Momentum Predictor
M_Uxs = linalg.solve(M_Au, M_Bup)
M_Uys = linalg.solve(M_Av, M_Bvp)
Uxs = np.reshape(M_Uxs, (ny, nx+1))
Uys = np.reshape(M_Uys, (ny+1, nx))
M_Ap, M_Bpp, App, Ape, Apw, Apn, Aps, Bpp = P_coeffSIMPLE(Aup, Avp, Uxs, Uys, D, nx, ny, dx, dy)
if(flag_Outlet==0):
M_Ap[int(ny*nx/4), :] = 0
M_Ap[int(ny*nx/4), int(ny*nx/4)] = 1
M_Bpp[int(ny*nx/4)] = 0
# Pressure Correction values
M_Pc = linalg.solve(M_Ap, M_Bpp)
Pc = np.reshape(M_Pc, (ny, nx))
# Residuals
Res_U = M_Au.dot(Uxo.flatten())-M_Bup
Res_V = M_Av.dot(Uyo.flatten())-M_Bvp
logRes_U = np.log(np.sum(np.abs(Res_U)))
logRes_V = np.log(np.sum(np.abs(Res_V)))
logRes_Mass = np.log(np.sum(np.abs(Bpp)))
# Momentum & Pressure Correction step
Ux, Uy, P = correctionSIMPLE(Uxs, Uys, Po, Pc, D, Aup, Avp, urf_UV, urf_P, nx, ny, dx, dy)
# Writing Results
Ux_values.append(Ux.copy())
Uy_values.append(Uy.copy())
P_values.append(P.copy())
Res_U_values.append(logRes_U)
Res_V_values.append(logRes_V)
Res_Mass_values.append(logRes_Mass)
# Prepping for next step
Uxo = Ux.copy()
Uyo = Uy.copy()
Po = P.copy()
iter_ = np.linspace(0, n+1, n+1)
ax.set_xlim(-0.5, n+2)
max_Res=0
min_Res=0
for k in range (0, n+1):
if(max_Res<Res_U_values[k]):
max_Res=Res_U_values[k]
if(max_Res<Res_V_values[k]):
max_Res=Res_U_values[k]
if(max_Res<Res_Mass_values[k]):
max_Res=Res_Mass_values[k]
if(min_Res>Res_U_values[k]):
min_Res=Res_U_values[k]
if(min_Res>Res_V_values[k]):
min_Res=Res_U_values[k]
if(min_Res>Res_Mass_values[k]):
min_Res=Res_Mass_values[k]
ax.set_ylim(min_Res-1, max_Res+1)
line1.set_ydata(Res_U_values)
line1.set_xdata(iter_)
line2.set_ydata(Res_V_values)
line2.set_xdata(iter_)
line3.set_ydata(Res_Mass_values)
line3.set_xdata(iter_)
fig.canvas.draw()
fig.canvas.flush_events()
n+=1
if(n<max_iter):
max_iter=n
max_iter
uxq_values = []
uyq_values = []
for n in range (0, max_iter):
ux1 = Ux_values[n].copy()
uxq = np.zeros((2*ny+1, 2*nx+1))
for i in range (0, ny):
for j in range (0, nx+1):
uxq[2*i+1, 2*j] = ux1[i, j]
for j in range (0, nx+1):
uxq[0, 2*j] = D[1][0, j]
uxq[-1, 2*j] = D[1][-1, j]
for i in range (0, ny-1):
for j in range (0, nx+1):
uxq[2*i+2, 2*j] = (uxq[2*i+1, 2*j] + uxq[2*i+3, 2*j])/2
for i in range (0, 2*ny):
for j in range (0, nx):
uxq[i, 2*j+1] = (uxq[i, 2*j] + uxq[i, 2*j+2])/2
uy1 = Uy_values[n].copy()
uyq = np.zeros((2*ny+1, 2*nx+1))
for i in range (0, ny+1):
for j in range (0, nx):
uyq[2*i, 2*j+1] = uy1[i, j]
for i in range (0, ny+1):
uyq[2*i, 0] = D[2][i, 0]
uyq[2*i, -1] = D[2][i, -1]
for i in range (0, ny+1):
for j in range (0, nx-1):
uyq[2*i, 2*j+2] = (uyq[2*i, 2*j+1] + uyq[2*i, 2*j+3])/2
for i in range (0, ny):
for j in range (0, 2*nx):
uyq[2*i+1, j] = (uyq[2*i, j] + uyq[2*i+2, j])/2
uxq_values.append(uxq)
uyq_values.append(uyq)
#%%
flag_Validation = input("Validation check for Lid-driven Cavity Re-[100, 1000, 5000] ?? [y/n]")
if(flag_Validation=='y'):
mpl.rcParams.update({'font.size': 10})
ghia_u100 = np.array([1, 0.84123, 0.78871, 0.73722, 0.68717, 0.23151, 0.00332, -0.13641, -0.20581, -0.2109, -0.15662, -0.1015, -0.06434, -0.04775, -0.04192, -0.03717, 0])
ghia_u1000 = np.array([1, 0.65928, 0.57492, 0.51117, 0.46604, 0.33304, 0.18719, 0.05702, -0.0608, -0.10648, -0.27805, -0.38289, -0.2973, -0.2222, -0.20196, -0.18109, 0])
ghia_u5000 = np.array([1, 0.48223, 0.4612, 0.45992, 0.46036, 0.33556, 0.20087, 0.08183, -0.03039, -0.07404, -0.22855, -0.3305, -0.40435, -0.43643, -0.42901, -0.41165, 0])
ghia_y = np.array([1, 0.9766, 0.9688, 0.9609, 0.9531, 0.8516, 0.7344, 0.6172, 0.5, 0.4531, 0.2813, 0.1719, 0.1016, 0.0703, 0.0625, 0.0547, 0])
yq = np.linspace(yMax, yMin, num=2*ny+1)
Re = rho*D[1][0, int(nx/2)]*Lx/visc
if(Re==100):
plt.scatter(ghia_u100, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 100 Mesh -[{}X{}]'.format(nx, ny))
if(Re==1000):
plt.scatter(ghia_u1000, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 1000 Mesh -[{}X{}]'.format(nx, ny))
if(Re==5000):
plt.scatter(ghia_u5000, ghia_y, c='green', label='Ghia etal.')
plt.title('Reynolds No. 5000 Mesh -[{}X{}]'.format(nx, ny))
plt.plot(uxq_values[max_iter-1][:, nx], yq, label ='Centreline X-Velocity')
plt.legend()
plt.show()
flag_Validation = input("Validation check for Fully developed flow ?? [y/n]")
if(flag_Validation=='y'):
mpl.rcParams.update({'font.size': 10})
Re = rho*D[1][int(ny/2), 0]*Ly/visc
yq = np.linspace(yMax, yMin, num=2*ny+1)
plt.plot(uxq_values[max_iter-1][:, int(8*(2*nx+1)/10)], yq, label ='Centreline X-Velocity - at X={}'.format(xMin+int(8*(2*nx+1)/10)*dx/2))
# plt.set_xlabel('Y')
plt.title('Fully Developed Flow Re = {}'.format(Re))
plt.legend()
plt.show()
xq = np.linspace(xMin, xMax, num=2*nx+1)
plt.plot(uxq_values[max_iter-1][ny, :], xq, label ='Centreline X-Velocity - at Y={}'.format(yMax-ny*dy/2))
# plt.set_xlabel('X')
plt.title('Fully Developed Flow Re = {}'.format(Re))
plt.legend()
plt.show()
#%%
postProcessor(P_values, uxq_values, uyq_values, \
xMin, xMax, yMin, yMax, nx, ny, dx, dy, Points_x, Points_y, \
caseFolder, Res_U_values, Res_V_values, Res_Mass_values, \
max_iter, min_Res, max_Res) | 2D-Panel-CFD | /2D_Panel-CFD-0.0.1.tar.gz/2D_Panel-CFD-0.0.1/src/RUN_package/RUN.py | RUN.py |
# 2D Cellular Automaton
This project was inspired by discussions in MATH 340 Mathematical Excursions. While we visualized multiple starting indicies for 2D cellular automata in Excel, I knew a Python script would allow greater functioniality and easier usage.
I came across a respository on GitHub by Zhiming Wang titled [rule30](https://github.com/zmwangx/rule30). Nearly all the code is borrowed from there and made it unnecessary for me to start from scratch. All the functionalities from Wang's solution exist in this project, with the only additions being supporting multiple starting indicies.
# Table of Contents
1. [Installation](#Installation)
2. [Usage](#Usage)
4. [Credit](#Credit)
5. [License](License)
## Installation
`pip install 2DCellularAutomaton`
## Usage
```python
from CellularAutomaton import Automaton
rows = 100 #Any positive number
rule = 30 #From 1-256. More can be seen here https://mathworld.wolfram.com/ElementaryCellularAutomaton.html
starting_indicies = [20, 60] #Note this refers to the columns and columns = 2 * rows - 1, which is why rows - 1 yields center.
block_size = 1
automata = Automaton(rows=rows, rule=rule, starting_indicies=starting_indicies)
image = automata.image(block_size=block_size)
image.save('Rule 30 | Column 20 and 60.jpeg')
```
Output
<img src="image.jpeg" alt="drawing" width="600"/>
## Credit
1. Zhiming Wang's [rule30](https://github.com/zmwangx/rule30)
## License
MIT | 2D-cellular-automaton | /2D-cellular-automaton-0.0.1.tar.gz/2D-cellular-automaton-0.0.1/README.md | README.md |
import bitarray
from . import visualize
from typing import Literal
class Automaton(object):
"""
An elementary cellular automaton with muliple initial state support.
The number of rows, `rows`, is given at class instantiation, and the
automaton is only simulated to that depth. Horizontally, we only
keep the states of the 2 * `rows` - 1 cells centered around the
initial 1.
One can access the history matrix via `matrix` or as a numpy array
via `nparray`, or as a printable string via `string`, or as an image
via `image`.
Parameters
----------
rows : int
rule : int, optional
The Wolfram code for the rule (in the range [0, 255]). See
`Wolfram code <https://en.wikipedia.org/wiki/Wolfram_code>`_ on
Wikipedia. Default is 30.
starting_indicies: list[int], optional
Defaults to rows - 1.
method: str, optional
'New' results in faster generation while 'Old' utilizies the separate
generation methods dependent on parity of rule.
Nearly all of the code is from https://github.com/zmwangx/rule30.
"""
def __init__(self, rows: int, rule: int = 30,
starting_indicies: list[int] = [],
method: Literal['New', 'Old'] = 'New'):
if type(rows) is not int or rows < 0:
raise ValueError("The rows should be a positive integer.")
self._rows = rows
self._columns = rows * 2 - 1
if type(starting_indicies) is not list or not all(
[type(index) is int and index <= rows * 2 - 1
for index in starting_indicies]):
raise ValueError('The starting indicies should be a list of \
integers less than 2 * rows - 1.')
elif len(starting_indicies) == 0:
self._starting_indicies = [rows - 1]
else:
self._starting_indicies = starting_indicies
if type(rule) is not int or not 0 <= rule <= 255:
raise ValueError("The rule should be an integer between 0-255.")
self._rule = rule
# Unpack rule
u = [bit == '1' for bit in reversed('{:08b}'.format(rule))]
# Wolfram code is big-endian in terms of the bit position of
# each of the 2^3=8 configurations (just like how we write
# numbers in a left-to-right system); we map the ruleset to
# little-endian form, so that, for instance, the rule for 110 is
# stored in 0b011.
self._rule_unpacked = [
u[0b000], # 000
u[0b100], # 001
u[0b010], # 010
u[0b110], # 011
u[0b001], # 100
u[0b101], # 101
u[0b011], # 110
u[0b111], # 111
]
if type(method) is not str and method not in ['New', 'Old']:
raise ValueError('The method should be a string New or Old.')
self._method = method
self._matrix = []
self._generate()
def __str__(self):
return self.string()
@property
def rows(self):
"""Number of rows in the history matrix.
Returns
-------
int
"""
return self._rows
@property
def columns(self):
"""Number of columns in the history matrix.
Always equals 2 * `rows` - 1.
Returns
-------
int
"""
return self._columns
@property
def starting_indicies(self):
"""The custom starting indicies of the first row.
Returns
-------
list[int]
"""
return self._starting_indicies
@property
def rule(self):
"""Wolfram code for the rule.
Returns
-------
int
"""
return self._rule
@property
def method(self):
"""'New' refers to the `generate_both` function while
'Old' refers to `generate_even`and `generate_odd` depending
on the parity of rule.
Returns
-------
str
"""
return self._method
@property
def matrix(self):
"""The history matrix.
This is a list of `rows` rows, where each row is a bitarray of
length `columns`. See `bitarray's reference
<https://pypi.python.org/pypi/bitarray>`_ for more details.
This is the internal representation of the `Automaton` class.
Returns
-------
List[bitarray]
"""
return self._matrix
def string(self, zero='0', one='1'):
"""Returns a printable string representation of the matrix.
Parameters
----------
zero : str, optional
The character to print for a cell of value 0. Default is '0'.
one : str, optional
The character to print for a cell of value 1. Default is '1'.
Returns
-------
str
Examples
--------
>>> import rule30
>>> print(rule30.Automaton(5, rule=30).string())
000010000
000111000
001100100
011011110
110010001
"""
return '\n'.join([''.join([one if bit else zero for bit in row])
for row in self._matrix])
def image(self, block_size=1):
"""Returns an image for the matrix.
Parameters
----------
block_size : int, optional
Size in pixels of each cell (drawn as a square). Default is 1.
Returns
-------
PIL.Image.Image
"""
return visualize.image_from_matrix(self._matrix, block_size=block_size)
@staticmethod
def _zeros(length):
# Returns a zeroed little-endian bitarray of specified length
buf = bitarray.bitarray(length, endian='little')
buf.setall(0)
return buf
def _generate(self):
if self.method == 'New':
self._gen_both()
else:
self._gen_even() if self.rule % 2 == 0 else self._gen_odd()
def _gen_both(self):
rows = self._rows
columns = self._columns
rule_unpacked = self._rule_unpacked
row = self._zeros(columns)
for index in self.starting_indicies:
row[index] = 1 # Multiple starting states
self._matrix.append(row)
# Evolution
for i in range(1, rows):
lastrow = row
row = self._zeros(columns)
for j in range(0, columns):
row[j] = rule_unpacked[int.from_bytes(
lastrow[j - 1: j + 2].tobytes(), 'little')]
self._matrix.append(row)
# I found this function to be slower than _gen_both.
def _gen_even(self):
rows = self._rows
columns = self._columns
rule_unpacked = self._rule_unpacked
row = self._zeros(columns)
for index in self.starting_indicies:
row[index] = 1 # Multiple starting states
self._matrix.append(row)
# Evolution
for i in range(1, rows):
lastrow = row
row = self._zeros(columns)
max_left_end = max(min(self.starting_indicies) - i - 1, 1)
max_right_end = max(max(self.starting_indicies) + i, columns - 1)
for j in range(max_left_end, max_right_end):
if len(row[j - 1:]) < 3:
continue
row[j] = rule_unpacked[int.from_bytes(
lastrow[j - 1: j + 2].tobytes(), 'little')]
# Leftover code from previous version, unsure if still necessary.
# The left and right endpoints of the last row need special
# attention because we don't have all three neighbors from
# the previous row.
if i == rows - 1:
row[0] = rule_unpacked[lastrow[0] * 2 + lastrow[1] * 4]
row[columns - 1] = rule_unpacked[lastrow[columns - 2] +
lastrow[columns - 1] * 2]
self._matrix.append(row)
# I have not figured out how to approach this like with _gen_even.
# I found this function to also perform slower than _gen_both.
def _gen_odd(self):
rows = self._rows
columns = self._columns
rule_unpacked = self._rule_unpacked
# In order to compute the states of the middle (2n-1) cells on
# the n-th row, we need to start from the states of the middle
# (4n-3) cells on the first row, and step by step compute the
# middle (4n-3-2i) cells on the (i+1)-th row.
row = self._zeros(4 * rows - 3)
row[2 * rows - 1] = 1
self._matrix.append(row[rows - 1: rows - 1 + columns])
# Evolution
for i in range(1, rows):
lastrow = row
columns_to_compute = 4 * rows - 3 - 2 * i
row = self._zeros(columns_to_compute)
for j in range(columns_to_compute):
row[j] = rule_unpacked[int.from_bytes(
lastrow[j: j + 3].tobytes(), 'little')]
self._matrix.append(row[rows - 1 - i: rows - 1 - i + columns]) | 2D-cellular-automaton | /2D-cellular-automaton-0.0.1.tar.gz/2D-cellular-automaton-0.0.1/CellularAutomaton/automaton.py | automaton.py |
# 2Keys
A easy to setup second keyboard, designed for everyone.
For a full setup guide, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/SETUP.md)
For keyboard mappings, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/MAPPINGS.md)
### Support
Windows is supported only as the server (where the hotkeys will run) and a raspberry pi is required to run the detector.
## WARNING
This will download a copy of [AutoHotkey_H](https://hotkeyit.github.io/v2/), a DLL version of [AutoHotkey](http://autohotkey.com/)
## Building
To build the server, where hotkeys are run:
```
$ cd server
$ yarn
```
To build the detector:
```
$ cd detector
$ pip3 install -r required.txt
```
## Devices
**Server**: The device running the hotkeys sever, i.e. where the hot keys will be run
**Detecter**: Device that handles detection of key presses & which keyboard it is and sends this to the server
## Sofware used & inspiration
Inspired by LTT editor Taran's second keyboard project: [https://github.com/TaranVH/2nd-keyboard](https://github.com/TaranVH/2nd-keyboard)
2Keys uses AutoHotkey_H (a DLL version of AutoHotkey): [https://hotkeyit.github.io/v2/](https://hotkeyit.github.io/v2/)
## License
Copyright 2018 Kishan Sambhi
2Keys is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
2Keys is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with 2Keys. If not, see <https://www.gnu.org/licenses/>. | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/README.md | README.md |
# This file is part of 2Keys.
# 2Keys is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 2Keys is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with 2Keys. If not, see <https://www.gnu.org/licenses/>.
###
# File generated by 2Keys
# DO NOT MODIFY
# Please run using sudo
# 2Keys script to register and handler systemd services for 2Keys watchers
keyboards={{ keyboards }} # Please use format (keyboard keyboard keyboard)
# Functions
register() {
echo Registering services...
for keyboard in ${keyboards[@]};
do
echo "Adding script for ${keyboard}..."
echo "Chmodding with 644..."
chmod 644 ./.2Keys/2Keys-${keyboard}.service
echo "Adding..."
systemctl enable $PWD/.2Keys/2Keys-${keyboard}.service
done
echo Reloading daemon...
systemctl daemon-reload
start
}
disable() {
echo Disabling services...
stop
for keyboard in ${keyboards[@]};
do
echo "Disabling script for ${keyboard}..."
systemctl disable 2Keys-${keyboard}.service
echo "To completely remove the scripts, remove the ./.2Keys dir."
echo "Note that you will be unable to ever reuse the 2Keys services again once this is done"
done
}
enable_scripts() {
echo Enabling services...
for keyboard in ${keyboards[@]};
do
echo "Enabling script for ${keyboard}..."
systemctl enable $PWD/.2Keys/2Keys-${keyboard}.service
done
}
start() {
echo Starting services...
for keyboard in ${keyboards[@]};
do
echo "Starting script for ${keyboard}..."
systemctl start 2Keys-${keyboard}.service
done
}
stop() {
echo Stopping services...
for keyboard in ${keyboards[@]};
do
echo "Stopping script for ${keyboard}..."
systemctl stop 2Keys-${keyboard}.service
done
}
restart() {
echo Restarting services...
for keyboard in ${keyboards[@]};
do
echo "Restarting script for ${keyboard}..."
systemctl restart 2Keys-${keyboard}.service
done
}
status() {
echo Getting statuses of services...
for keyboard in ${keyboards[@]};
do
echo "Get status of ${keyboard}..."
systemctl status 2Keys-${keyboard}.service
echo ""
done
}
# Root check
if [ "$EUID" -ne 0 ]
then echo "Please run as root"
exit 1
fi
# Parse arg
case $1 in
register)
register
;;
disable)
disable
;;
enable)
enable_scripts
;;
start)
start
;;
stop)
stop
;;
restart)
restart
;;
status)
status
;;
help)
echo Valid comands:
echo "register: Registers and enables (starts on startup) services for use"
echo "disable: Disbales services (stops them being started on startup)"
echo "enable: Enables services (used after disabled has been run)"
echo "start: Starts services"
echo "stop: Stops services"
echo "restart: Restarts services"
echo "status: Gets statuses of all services"
;;
*)
echo Invalid command.
exit 1
;;
esac | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/assets/register.sh | register.sh |
import sys
import requests
import json
import os
from os import path
import yaml
import colorful
from ..util.constants import SCRIPTS_ROOT, DEFAULT_PORT, MODULE_NAME
from ..util.logger import Logger
from ..util.config import load_config
from ..daemon import generate_daemon
from ..add_keyboard import add_keyboards
logger = Logger("init")
def init(**args):
logger.info("Welcome to the INIT for the detector!")
ipv4 = None
port = DEFAULT_PORT
# Use opts if we can
if args["address"] == None:
logger.info("First we need to know where to find the server")
logger.info("Enter the ipv4 address of the server below:")
ipv4 = input("")
else:
ipv4 = args["address"]
# Port arg
if args["port"] == None:
logger.info("Enter the port of the server below:")
port = input("")
else:
port = args["port"]
# Make request, get config in JSON format
logger.info("Fetching config...")
try:
config_json = requests.get("http://" + ipv4 + ":" + port + "/api/get/config")
except requests.exceptions.ConnectionError:
logger.err("Couldn't estanblish a connection to the server.")
logger.err("Please check your internet connection.")
exit() # Can't do any more
if config_json.status_code >= 400: # i.e. 404 or 500
logger.err("ERROR: Request for config unsucessful!")
logger.err("Got status code " + str(config_json.status_code) + " with response:")
logger.err(config_json.text)
logger.debug("Headers: ")
logger.debug(config_json.headers)
exit()
config = json.loads(config_json.text)
# Save config
logger.info("Saving config to " + os.getcwd() + "...")
logger.debug("Opening config file handler...")
config_file = open("config.yml", "w")
logger.debug("Writing config...")
config_file.write("# Config for 2Keys\n# ONLY FOR USE BY THE PROGRAM\n# To change the config, update it on the client and run \"2Keys config-update\" here\n" +
yaml.dump(config, default_flow_style=False))
config_file.close() # Needed so that add keyboard can read it
# Then scan for keyboards
# Since running directly from here causes issues with async not stopping etc, holding everything up
# run 2Keys add
# (essentially run in another process)
# Do for each keyboard in config.keyboards
logger.info("Running scripts to add path for keyboard input...")
# Check for --no-path-request, which implies paths are already in config
if args["no_path_request"]:
logger.warn("--no-path-request flag was given")
logger.warn("It is assumed all keyboard /dev/input paths are already given in the config.")
logger.warn("Skipping to daemon generation.")
else:
add_keyboards(config)
# Add daemons
generate_daemon(config["name"], config["keyboards"].keys()) | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/init/init.py | init.py |
# CLI for 2Keys
# I'm just making my own since that's easier for me to understand
import click
import sys
from ..watcher import Keyboard
from ..util import Logger, load_config, constants
from ..add_keyboard import gen_async_handler, add_keyboard
from ..init import init as init_cli
from ..sync import sync_config
from ..daemon import generate_daemon
logger = Logger("cli")
@click.group()
@click.option("--debug", is_flag=True, help="Enable debugging")
@click.option("--silent", is_flag=True, help="Don't log")
def cli(debug, silent):
return
@cli.command()
@click.option("--address", "-a", help="Specify the IPv4 address of the server")
@click.option("--port", "-p", help="Specify the port the server is running on")
@click.option("--no-path-request", is_flag=True, help="Don't run the interactive keyboard detector (assumes all /dev/input/ paths have already been put into the config on the server)")
def init(address, port, no_path_request):
init_cli(address=address, port=port, no_path_request=no_path_request)
@cli.command()
@click.option("-y", "--yes", is_flag=True, help="Don't ask for prompts")
def sync(yes):
logger.warn("This will overwrite the copy of the config on the detector. Proceed? [Y/n]")
proceed = ""
if yes:
logger.warn("-y flag was given. Proceeding...")
proceed = "y"
else:
# ASK
proceed = input("").lower()
# DO IT
if proceed == "y":
sync_config()
@cli.command()
@click.argument("keyboard", default="")
@click.option(
"--inputs-path",
"-i",
help="Provide an alternative path to use as the source of keyboard input 'files' (default: /dev/input/by-id)",
default=constants.KEYBOARDS_PATH_BASE
)
def add(keyboard, inputs_path):
add_keyboard(keyboard, gen_async_handler, inputs_path)
@cli.command()
@click.argument("keyboard")
@click.option("-n", "--no-lock", is_flag=True, help="Don't lock the keyboard")
def watch(keyboard, no_lock):
if keyboard == "":
logger.err("Please provide a keyboard to watch.")
exit()
# Keyboard specified, watch it
config = load_config()
keyboard = Keyboard(config["keyboards"][keyboard], keyboard)
if not no_lock:
try:
keyboard.lock() # Grabs keyboard
keyboard.watch_keyboard()
except (KeyboardInterrupt, SystemExit, OSError):
keyboard.unlock()
exit(0)
else:
keyboard.watch_keyboard()
# Command to generate daemons
@cli.command()
@click.argument("keyboards", nargs=-1, required=False)
def daemon_gen(keyboards):
logger.info("Generating daemon files...")
config = load_config()
keyboard_list = config["keyboards"].keys()
if keyboards != ():
# Use args instead
keyboard_list = keyboards
generate_daemon(config["name"], config["keyboards"].keys()) | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/cli/cli.py | cli.py |
import struct
import time
import sys
import aiofiles
import requests
import json
from evdev import InputDevice
from os import path
from ..util.constants import KEYBOARDS_PATH_BASE, KEYBOARD_EVENT_FORMAT, KEYBOARD_EVENT_SIZE, MAX_KEY_MAPS
from ..util.keyboard_map import keys as KEY_MAP
from ..util.config import load_config
from ..util.logger import Logger
logger = Logger("detect")
class Keyboard:
# keyboard: Keyboard config
# name: Name of keyboard
def __init__(self, keyboard, name):
self.config = load_config()
logger.debug("Got keyboard: " + str(keyboard))
self.keyboard = keyboard
self.name = name
# File for input that corresponds to the keyboard.
self.keyboard_path = keyboard["path"]
# Device from evdev storage
self.keyboard_device = InputDevice(self.keyboard_path)
# Array of pressed keys
# is array of booleans, with the index = key code
# i.e. if pressed_or_not[2] == true, then 2 has been pressed down. Once set to false, the key has been 'unpressed'
self.pressed_or_not = [False] * MAX_KEY_MAPS
# Current keys being pressed
self.keys = [""]
# Local stores of key mappings
self.map = KEY_MAP
# Apply mappings
if "map" in self.keyboard:
self.apply_mappings(self.keyboard["map"])
# Store hotkeys list
self.hotkeys = self.standardise_hotkeys(keyboard["hotkeys"])
# Store array of hotkeys split into chars as this makes checking easier
# current hotkey, used for when watching for an up event
self.current_hotkey_up = None
self.last_hotkey = None
# Custom mapping
# Takes in key/value of key: code and adds to map array
def apply_mappings(self, maps):
for key, code in maps.items():
logger.debug("Mapped " + key + " as (" + key + ") to code " + str(code))
self.map[code] = "(" + key + ")"
# Keyboard watcher
# TODO: Use const from evdev instead of manually checking for cleaner code and no magic numbers
def watch_keyboard(self):
logger.info("Watching for key presses on " + self.name + "...")
for event in self.keyboard_device.read_loop():
type = event.type
code = event.code
value = event.value
# We only want event type 1, as that is a key press
# If key is already pressed, ignore event provided value not 0 (key unpressed)
if (type == 1 or type == 0x1):
logger.info("Key pressed. Code %u, value %u. Mapping: %s" %
(code, value, self.map[code]))
# Set key in array
# Only done if value 1 so as to not conflict with ups
if value == 1:
self.change_key_state(code, value)
logger.debug(self.keys)
# Run alogrithm to check keys against hotkey
# Only run though if value is 0 or 1 to prevent duplicate hotkeys
if value < 2:
# Proceed with regular hotkey logic
checked_hotkey = self.check_for_hotkey(self.keys)
if checked_hotkey != False:
hotkey = self.hotkeys[checked_hotkey]
logger.info("Registered hotkey:")
logger.info(checked_hotkey)
logger.info(hotkey)
# Is is an up, down, or multi function?
if hotkey["type"] == "down" and value == 1:
self.send_hotkey(checked_hotkey, value)
elif hotkey["type"] == "up" and value == 0:
self.send_hotkey(checked_hotkey, value)
elif hotkey["type"] == "multi":
# The server handles picking the right hotkey
self.send_hotkey(checked_hotkey, value)
else:
logger.warn("Hotkey not send as it's type " + hotkey["type"])
# Set key in array
# Only done if value 0 so as to not conflict with downs
if value == 0:
self.change_key_state(code, value)
logger.debug(self.keys)
#elif type != 0 or code != 0 or value != 0:
# print("Event type %u, code %u, value %u at %d.%d" % \
# (type, code, value, tv_sec, tv_usec))
else:
# Events with code, type and value == 0 are "separator" events
print("===========================================")
# Handle change of state (down/up) of key code
# down = True
# Up (as in not pressed) = False
def change_key_state(self, code, value):
if value == 1:
# Key not yet pressed
self.pressed_or_not[code] = True
# Add to self.keys string
if isinstance(self.map[code], str):
self.keys = [combo + self.map[code] for combo in self.keys] # Add to each candidate combo
else:
# Array in use
# Add as different candidates
new_keys = []
for combo in self.keys:
for mapping in self.map[code]:
new_keys.append(combo + mapping)
self.keys = new_keys
elif value == 0:
# Key unpressed, remove
self.pressed_or_not[code] = False
# Remove from combos
if isinstance(self.map[code], str):
self.keys = [combo.replace(self.map[code], "") for combo in self.keys] # Remove from each combo
else:
# Array
for mapping in self.map[code]:
logger.debug("Checking mapping " + str(mapping))
new_keys = []
index = 0
while index < len(self.keys):
combo = self.keys[index]
if combo.find(mapping) >= 0 or combo == mapping: # Only should run if in, to avoid duplicates
new_combo = combo.replace(mapping, "")
if len(new_combo) > 0:
new_keys.append(new_combo) # Remove from each
index += 1
self.keys = new_keys
# If keys array is empty, make sure to add somewhere for next set
if len(self.keys) < 1:
self.keys = [""]
# Standardise hotkey config
# hotkey = hotkeys mappings
# Standard config:
# type: down
# func: Function
def standardise_hotkeys(self, hotkeys):
new_hotkeys = hotkeys
for key, value in new_hotkeys.items():
if isinstance(value, str):
# Only has function
new_hotkeys[key] = {
"type": "down",
"func": value
}
# Else it has to be a regular one OR a muti one as ups require type: up, muties just need an object
# The below fixes #13. where if no type was specified but a func: was the program crashes
elif "type" not in new_hotkeys[key]:
# Function is present, but no type
new_hotkeys[key]["type"] = ("down" if isinstance(value["func"], str) else "multi") # If func is str, use down, if not, use "multi"
return new_hotkeys
# Hotkey detector algorithm
# Return the key of the hotkey if hotkey
# candidate = array of hotkey strings to check
def check_for_hotkey(self, candidates):
# Check each candidate
for combo in candidates:
logger.debug("Checking hotkey in combo " + combo)
for key, mapping in self.hotkeys.items():
# Check each candidate
# Step 1: Check length. If lengths are different, hotkeys can't match
if len(key) != len(combo):
continue
# Step 2: Check if chars are equal
split_hotkey = list(key) # Split into array for easy checking
split_current_keys = list(combo)
if set(split_hotkey).issubset(set(split_current_keys)) or set(split_current_keys).issubset(set(split_hotkey)):
return key # Candidate and hotkey matches, return hotkey location
# If none are true, then this isn't the right one (function yet to return)
return False
# Hotkey sender
# Send hotkey runner command -> server
# hotkey = hotkey ref in config
# value = Value of event type (up, down) from evdev
def send_hotkey(self, hotkey, value):
logger.info("Sending hotkey %s to server..." % hotkey)
try:
data_hotkey = { "keyboard": self.name, "hotkey": hotkey, "value": value }
TYPE_JSON = {"Content-Type": "application/json"} # So the server can interpret it
requests.post("http://" + self.config["addresses"]["server"]["ipv4"] + ":" + str(self.config["addresses"]["server"]["port"]) + "/api/post/trigger", data=json.dumps(data_hotkey), headers=TYPE_JSON, timeout=2)
except requests.exceptions.ConnectionError:
logger.err("Couldn't estanblish a connection to the server.")
logger.err("Please check your internet connection.")
except requests.exceptions.Timeout:
logger.err("The request timed out")
logger.warn("This means either the server isn't running, or is busy running another hotkey.")
logger.warn("Please note the hotkey may still execute after the server has finished running the hotkeys it is currently running")
# Locks (grabs) keyboard
def lock(self):
logger.info("Locking keyboard....")
self.keyboard_device.grab()
# Unlocks (ungrabs) keyboard
def unlock(self):
logger.info("Unlocking keyboard...")
self.keyboard_device.ungrab()
# str keyboard: Keyboard file in /dev/input/by-id
class AsyncKeyboard:
# Root defaults to /dev/input/by-id
def __init__(self, keyboard, root):
# File for input that corresponds to the keyboard.
self.keyboard = path.join(root, keyboard)
# Open keyboard events file in binary mode
self.in_file = open(self.keyboard, "rb")
# Run checker
self.run = True
# IMPORTANT: Don't use non async functions in this. That includes the logger
async def keyboard_watcher(self, callback):
# Only seems to run on key press. Strange.
# Solution, as this makes it hard to stop was to add a callback to part 2
async with aiofiles.open(self.keyboard, "rb") as in_file:
event = await in_file.read(KEYBOARD_EVENT_SIZE) # Open input file
while event and self.run:
print("[ASYNC DEBUG] Key pressed on " + self.keyboard)
break;
await in_file.close()
# Stop all
if self.run:
await callback(self.keyboard)
return self.run
# Stop watching as it's no longer needed
async def stop_watch(self):
print("[DEBUG] CLASS: STOPPING " + self.keyboard)
self.run = False
return
#await self.in_file.close() | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/watcher/watch_keyboard.py | watch_keyboard.py |
Keyboard mappings
Copy paste from https://github.com/torvalds/linux/blob/master/include/uapi/linux/input-event-codes.h:
/*
* Keys and buttons
*
* Most of the keys/buttons are modeled after USB HUT 1.12
* (see http://www.usb.org/developers/hidpage).
* Abbreviations in the comments:
* AC - Application Control
* AL - Application Launch Button
* SC - System Control
*/
As such some c code is leftover (mostly '#define's.)
None = invalid key
An array of key mapping means multiple keys can correspond to it
Currently 249 keys are mapped
"""
from .constants import MAX_KEY_MAPS
# Applies custom tag to key names
def custom_name(name):
return "$" + name + "$"
#define KEY_(.*?) (0?[xX]?[0-9a-fA-F]+)(.*) # RegExp to convert everything in VSCode
#keys[$2] = "$1" # Replacement RegExp to convert everything in VSCode
keys = [""] * MAX_KEY_MAPS # Index corresponds to code
keys[0] = None # RESERVED
keys[1] = custom_name("ESC")
keys[2] = "1"
keys[3] = "2"
keys[4] = "3"
keys[5] = "4"
keys[6] = "5"
keys[7] = "6"
keys[8] = "7"
keys[9] = "8"
keys[10] = "9"
keys[11] = "0"
keys[12] = "-" # MINUS
keys[13] = "=" # EQUAL
keys[14] = custom_name("BACKSPACE") # BACKSPACE
keys[15] = custom_name("TAB")
keys[16] = "Q"
keys[17] = "W"
keys[18] = "E"
keys[19] = "R"
keys[20] = "T"
keys[21] = "Y"
keys[22] = "U"
keys[23] = "I"
keys[24] = "O"
keys[25] = "P"
keys[26] = ["[", "{"] # LEFTBRACE
keys[27] = ["]", "}"] # RIGHTBRACE
keys[28] = custom_name("ENTER") # ENTER
keys[29] = ["<^", "^"] # LEFTCTRL
keys[30] = "A"
keys[31] = "S"
keys[32] = "D"
keys[33] = "F"
keys[34] = "G"
keys[35] = "H"
keys[36] = "J"
keys[37] = "K"
keys[38] = "L"
keys[39] = ";" # SEMICOLON
keys[40] = "\'" # APOSTROPHE
keys[41] = "`" # GRAVE
keys[42] = ["<+", "+"] # LEFTSHIFT
keys[43] = "\\" # BACKSLASH
keys[44] = "Z"
keys[45] = "X"
keys[46] = "C"
keys[47] = "V"
keys[48] = "B"
keys[49] = "N"
keys[50] = "M"
keys[51] = "," # COMMA
keys[52] = "." # DOT
keys[53] = "/" # SLASH
keys[54] = ["+>", "+"] # RIGHTSHIFT
keys[55] = custom_name("NUM_*") # KEYPAD Asterisk
keys[56] = ["<!", "!"] # LEFTALT
keys[57] = custom_name("SPACE")
keys[58] = custom_name("CAPS") # CAPSLOCK
keys[59] = "F1"
keys[60] = "F2"
keys[61] = "F3"
keys[62] = "F4"
keys[63] = "F5"
keys[64] = "F6"
keys[65] = "F7"
keys[66] = "F8"
keys[67] = "F9"
keys[68] = "F10"
keys[69] = custom_name("NUMLOCK") # NUMLOCK
keys[70] = custom_name("SCROLLLOCK")
# For these, NUM was KP
keys[71] = "NUM7"
keys[72] = "NUM8"
keys[73] = "NUM9"
keys[74] = custom_name("NUM_-")
keys[75] = "NUM4"
keys[76] = "NUM5"
keys[77] = "NUM6"
keys[78] = custom_name("NUM_+")
keys[79] = "NUM1"
keys[80] = "NUM2"
keys[81] = "NUM3"
keys[82] = "NUM0"
keys[83] = custom_name("NUM_.")
# Not included because internationlisation is a pain & I have no idea what char to reference as
# Could be reenabled by surround ZENKAKUHANKAKU with $s and using as: (example config)
# hotkeys:
# $ZENKAKUHANKAKU$: SomeFunction
# Referenced as IC (Internationlisation confusion)
# keys[85] = "ZENKAKUHANKAKU"
keys[86] = custom_name("#") # 102ND key added to UK keyboard
keys[87] = "F11"
keys[88] = "F12"
# keys[89] = "RO" # No idea what this is, IC?
# keys[90] = "KATAKANA" # IC
# keys[91] = "HIRAGANA" # IC
# keys[92] = "HENKAN" # IC
# keys[93] = "KATAKANAHIRAGANA" # IC
# keys[94] = "MUHENKAN" # IC
# keys[95] = "KPJPCOMMA" # No idea what key this is
keys[96] = custom_name("NUM_ENTER") # KPENTER; _ used for readability
keys[97] = ["^>", "^"] # RIGHTCTRL; _ used for readability
keys[98] = custom_name("NUM_/") # KPSLASH
keys[99] = custom_name("PRINT_SCR") # Print Screen & SYSREQ. SYSREQ is used for recovery. Thus, should throw an error if the user tries to use so the system can be recovered
keys[100] = ["!>", "!"]
keys[101] = custom_name("LINE_FEED") # New line char, backwards-compatibility; _ used for readability
keys[102] = custom_name("HOME")
keys[103] = custom_name("UP")
keys[104] = custom_name("PAGE_UP") # _ used for readability
keys[105] = custom_name("LEFT")
keys[106] = custom_name("RIGHT")
keys[107] = custom_name("END")
keys[108] = custom_name("DOWN")
keys[109] = custom_name("PAGE_DOWN") # _ used for readability
keys[110] = custom_name("INSERT")
keys[111] = custom_name("DELETE")
keys[112] = custom_name("MACRO") # Macro key from old keyboards. NOT new macro keys from i.e. Corsair keyboard. Backwards-compatibility
keys[113] = custom_name("MUTE") # KEY_MIN_INTERESTING (see bottom)
keys[114] = custom_name("VOL_DOWN") # VOLUMEUP. _ used for readability
keys[115] = custom_name("VOL_UP") # VOLUMEUP
keys[116] = None # POWER; Throw error so the user can power the system down
keys[117] = custom_name("NUM_=") # Numpad equals
keys[118] = custom_name("NUM_+-") # KPPLUSMINUS
keys[119] = custom_name("PAUSE")
keys[120] = custom_name("SCALE")
keys[121] = custom_name("NUM_,") # KP Comma
# keys[122] = "HANGEUL" # IC
#define KEY_HANGUEL KEY_HANGEUL # Leftover from Linux
keys[123] = "HANJA" # IC
keys[124] = "YEN" # IC
keys[125] = [custom_name("LEFTMETA"), "#", "<#"] # IC, Windows key
keys[126] = [custom_name("RIGHTMETA"), "#", "#>"] # IC, Windows key
keys[127] = [custom_name("COMPOSE"), custom_name("CONTEXT_MENU")] # Compose two chars, useful as a mode key. Also the context menu key
keys[128] = custom_name("STOP") # Stop key, don't know what for. NOT MEDIA CONTROL
keys[129] = custom_name("AGAIN")
keys[130] = custom_name("PROPS")
keys[131] = custom_name("UNDO")
keys[132] = custom_name("FRONT")
keys[133] = custom_name("COPY")
keys[134] = custom_name("OPEN")
keys[135] = custom_name("PASTE")
keys[136] = custom_name("FIND")
keys[137] = custom_name("CUT")
keys[138] = custom_name("HELP")
keys[139] = custom_name("MENU")
keys[140] = custom_name("CALC")
keys[141] = custom_name("SETUP")
keys[142] = custom_name("SLEEP")
keys[143] = custom_name("WAKEUP")
keys[144] = custom_name("FILE")
keys[145] = custom_name("SENDFILE")
keys[146] = custom_name("DELETEFILE")
keys[147] = custom_name("XFER")
keys[148] = custom_name("PROG1")
keys[149] = custom_name("PROG2")
keys[150] = custom_name("WWW")
keys[151] = custom_name("MSDOS")
keys[152] = [custom_name("COFFEE"), custom_name("SCREEN_LOCK")]
#define KEY_SCREENLOCK KEY_COFFEE
keys[153] = custom_name("ROTATE_DISPLAY")
#define KEY_DIRECTION KEY_ROTATE_DISPLAY
keys[154] = custom_name("CYCLE_WINDOWS")
keys[155] = custom_name("MAIL")
keys[156] = custom_name("BOOKMARKS")
keys[157] = custom_name("COMPUTER")
keys[158] = custom_name("BACK")
keys[159] = custom_name("FORWARD")
keys[160] = custom_name("CLOSE_CD")
keys[161] = custom_name("EJECT_CD")
keys[162] = custom_name("EJECT_CLOSE_CD")
keys[163] = custom_name("MEDIA_NEXT") # CD
keys[164] = custom_name("MEDIA_PLAY_PAUSE") # CD
keys[165] = custom_name("MEDIA_PREVIOUS") # CD
keys[166] = custom_name("MEDIA_STOP") # CD
keys[167] = custom_name("MEDIA_RECORD") # RECORD
keys[168] = custom_name("MEDIA_REWIND") # REWIND
keys[169] = custom_name("PHONE") # Media Select Telephone
keys[170] = custom_name("ISO")
keys[171] = custom_name("CONFIG")
keys[172] = custom_name("APP_HOMEPAGE") # AC
keys[173] = custom_name("APP_REFRESH") # AC
keys[174] = custom_name("APP_EXIT") # AC
keys[175] = custom_name("MOVE")
keys[176] = custom_name("EDIT")
keys[177] = custom_name("SCROLL_UP")
keys[178] = custom_name("SCROLL_DOWN")
# keys[179] = custom_name("KPLEFTPAREN") # What is this?
# keys[180] = custom_name("KPRIGHTPAREN") # What is this?
keys[181] = custom_name("APP_NEW") # AC
keys[182] = custom_name("APP_REDO") # AC
keys[183] = "F13"
keys[184] = "F14"
keys[185] = "F15"
keys[186] = "F16"
keys[187] = "F17"
keys[188] = "F18"
keys[189] = "F19"
keys[190] = "F20"
keys[191] = "F21"
keys[192] = "F22"
keys[193] = "F23"
keys[194] = "F24"
keys[200] = custom_name("MEDIA_PLAY") # Different to MEDIA_PLAY_PAUSE, this button can only play not pause. (CDs)
keys[201] = custom_name("MEDIA_PAUSE")
# keys[202] = custom_name("PROG3") # Programmable buttons?
# keys[203] = custom_name("PROG4") # Programmable buttons?
keys[204] = custom_name("DASHBOARD")
keys[205] = custom_name("SUSPEND")
keys[206] = custom_name("CLOSE")
keys[207] = custom_name("PLAY") # How is this different to keys[200]
keys[208] = custom_name("MEDIA_FASTFORWARD")
keys[209] = custom_name("SOUND_BASSBOOST")
keys[210] = custom_name("PRINT")
keys[211] = custom_name("HP")
keys[212] = custom_name("CAMERA")
keys[213] = custom_name("SOUND")
keys[214] = custom_name("QUESTION")
keys[215] = custom_name("EMAIL")
keys[216] = custom_name("CHAT")
keys[217] = custom_name("SEARCH")
keys[218] = custom_name("CONNECT")
keys[219] = custom_name("FINANCE") # Launch Finance app
keys[220] = custom_name("SPORT")
keys[221] = custom_name("SHOP")
keys[222] = custom_name("ALTERASE")
keys[223] = custom_name("CANCEL")
keys[224] = custom_name("BRIGHTNESS_DOWN")
keys[225] = custom_name("BRIGHTNESS_UP")
keys[226] = custom_name("MEDIA")
keys[227] = custom_name("SWITCHVIDEOMODE") # "Cycle between available video outputs"
# keys[228] = custom_name("KBDILLUMTOGGLE") # What are these?
# keys[229] = custom_name("KBDILLUMDOWN") # What are these?
# keys[230] = custom_name("KBDILLUMUP") # What are these?
keys[231] = custom_name("APP_SEND") # AC
keys[232] = custom_name("APP_REPLY") # AC
keys[233] = custom_name("APP_FORWARDMAIL") # AC
keys[234] = custom_name("APP_SAVE") # AC
keys[235] = custom_name("DOCUMENTS")
keys[236] = custom_name("BATTERY")
keys[237] = custom_name("SET_BLUETOOTH") # Bluetooth on/off
keys[238] = custom_name("SET_WLAN") # Wifi on/off
keys[239] = custom_name("SET_UWB") # UWB is a radio type (like 2G, 3G, wifi)
keys[240] = custom_name("UNKNOWN") # As it says, unknown
keys[241] = custom_name("VIDEO_SOURCE_NEXT") # next video source
keys[242] = custom_name("VIDEO_SOURCE_PREV") # previous video source
keys[243] = custom_name("BRIGHTNESS_CYCLE") # "brightness up, after max is min"
keys[244] = custom_name("BRIGHTNESS_AUTO") # Auto brightness, "rely on ambient"
#define KEY_BRIGHTNESS_ZERO KEY_BRIGHTNESS_AUTO
keys[245] = custom_name("DISPLAY_OFF")
keys[246] = custom_name("SET_WWAN") # "Wireless WAN (LTE, UMTS, GSM, etc.)". KEY_WWAN
#define KEY_WIMAX KEY_WWAN # ALias for above
keys[247] = custom_name("RFKILL") # "Key that controls all radios"
keys[248] = custom_name("MICMUTE") # Microphone mute
# "Code 255 is reserved for special needs of AT keyboard driver"
# I think this is mouse stuff, so it remains commented out
#define BTN_MISC 0x100
#define BTN_0 0x100
#define BTN_1 0x101
#define BTN_2 0x102
#define BTN_3 0x103
#define BTN_4 0x104
#define BTN_5 0x105
#define BTN_6 0x106
#define BTN_7 0x107
#define BTN_8 0x108
#define BTN_9 0x109
#define BTN_MOUSE 0x110
#define BTN_LEFT 0x110
#define BTN_RIGHT 0x111
#define BTN_MIDDLE 0x112
#define BTN_SIDE 0x113
#define BTN_EXTRA 0x114
#define BTN_FORWARD 0x115
#define BTN_BACK 0x116
#define BTN_TASK 0x117
#define BTN_JOYSTICK 0x120
#define BTN_TRIGGER 0x120
#define BTN_THUMB 0x121
#define BTN_THUMB2 0x122
#define BTN_TOP 0x123
#define BTN_TOP2 0x124
#define BTN_PINKIE 0x125
#define BTN_BASE 0x126
#define BTN_BASE2 0x127
#define BTN_BASE3 0x128
#define BTN_BASE4 0x129
#define BTN_BASE5 0x12a
#define BTN_BASE6 0x12b
#define BTN_DEAD 0x12f
#define BTN_GAMEPAD 0x130
#define BTN_SOUTH 0x130
#define BTN_A BTN_SOUTH
#define BTN_EAST 0x131
#define BTN_B BTN_EAST
#define BTN_C 0x132
#define BTN_NORTH 0x133
#define BTN_X BTN_NORTH
#define BTN_WEST 0x134
#define BTN_Y BTN_WEST
#define BTN_Z 0x135
#define BTN_TL 0x136
#define BTN_TR 0x137
#define BTN_TL2 0x138
#define BTN_TR2 0x139
#define BTN_SELECT 0x13a
#define BTN_START 0x13b
#define BTN_MODE 0x13c
#define BTN_THUMBL 0x13d
#define BTN_THUMBR 0x13e
#define BTN_DIGI 0x140
#define BTN_TOOL_PEN 0x140
#define BTN_TOOL_RUBBER 0x141
#define BTN_TOOL_BRUSH 0x142
#define BTN_TOOL_PENCIL 0x143
#define BTN_TOOL_AIRBRUSH 0x144
#define BTN_TOOL_FINGER 0x145
#define BTN_TOOL_MOUSE 0x146
#define BTN_TOOL_LENS 0x147
#define BTN_TOOL_QUINTTAP 0x148 /* Five fingers on trackpad */
#define BTN_STYLUS3 0x149
#define BTN_TOUCH 0x14a
#define BTN_STYLUS 0x14b
#define BTN_STYLUS2 0x14c
#define BTN_TOOL_DOUBLETAP 0x14d
#define BTN_TOOL_TRIPLETAP 0x14e
#define BTN_TOOL_QUADTAP 0x14f /* Four fingers on trackpad */
#define BTN_WHEEL 0x150
#define BTN_GEAR_DOWN 0x150
#define BTN_GEAR_UP 0x151
# NOTE: 0x160 != decimal 160
# Below here is the rest
# These are untouched since I have no idea if people would want to use them
# plus it would take too long to adjust them all
# Thus, they are disabled
# keys[0x160] = "OK"
# keys[0x161] = "SELECT"
# keys[0x162] = "GOTO"
# keys[0x163] = "CLEAR"
# keys[0x164] = "POWER2"
# keys[0x165] = "OPTION"
# keys[0x166] = "INFO"
# keys[0x167] = "TIME"
# keys[0x168] = "VENDOR"
# keys[0x169] = "ARCHIVE"
# keys[0x16a] = "PROGRAM"
# keys[0x16b] = "CHANNEL"
# keys[0x16c] = "FAVORITES"
# keys[0x16d] = "EPG"
# keys[0x16e] = "PVR"
# keys[0x16f] = "MHP"
# keys[0x170] = "LANGUAGE"
# keys[0x171] = "TITLE"
# keys[0x172] = "SUBTITLE"
# keys[0x173] = "ANGLE"
# keys[0x174] = "ZOOM"
# keys[0x175] = "MODE"
# keys[0x176] = "KEYBOARD"
# keys[0x177] = "SCREEN"
# keys[0x178] = "PC"
# keys[0x179] = "TV"
# keys[0x17a] = "TV2"
# keys[0x17b] = "VCR"
# keys[0x17c] = "VCR2"
# keys[0x17d] = "SAT"
# keys[0x17e] = "SAT2"
# keys[0x17f] = "CD"
# keys[0x180] = "TAPE"
# keys[0x181] = "RADIO"
# keys[0x182] = "TUNER"
# keys[0x183] = "PLAYER"
# keys[0x184] = "TEXT"
# keys[0x185] = "DVD"
# keys[0x186] = "AUX"
# keys[0x187] = "MP3"
# keys[0x188] = "AUDIO"
# keys[0x189] = "VIDEO"
# keys[0x18a] = "DIRECTORY"
# keys[0x18b] = "LIST"
# keys[0x18c] = "MEMO"
# keys[0x18d] = "CALENDAR"
# keys[0x18e] = "RED"
# keys[0x18f] = "GREEN"
# keys[0x190] = "YELLOW"
# keys[0x191] = "BLUE"
# keys[0x192] = "CHANNELUP"
# keys[0x193] = "CHANNELDOWN"
# keys[0x194] = "FIRST"
# keys[0x195] = "LAST"
# keys[0x196] = "AB"
# keys[0x197] = "NEXT"
# keys[0x198] = "RESTART"
# keys[0x199] = "SLOW"
# keys[0x19a] = "SHUFFLE"
# keys[0x19b] = "BREAK"
# keys[0x19c] = "PREVIOUS"
# keys[0x19d] = "DIGITS"
# keys[0x19e] = "TEEN"
# keys[0x19f] = "TWEN"
# keys[0x1a0] = "VIDEOPHONE"
# keys[0x1a1] = "GAMES"
# keys[0x1a2] = "ZOOMIN"
# keys[0x1a3] = "ZOOMOUT"
# keys[0x1a4] = "ZOOMRESET"
# keys[0x1a5] = "WORDPROCESSOR"
# keys[0x1a6] = "EDITOR"
# keys[0x1a7] = "SPREADSHEET"
# keys[0x1a8] = "GRAPHICSEDITOR"
# keys[0x1a9] = "PRESENTATION"
# keys[0x1aa] = "DATABASE"
# keys[0x1ab] = "NEWS"
# keys[0x1ac] = "VOICEMAIL"
# keys[0x1ad] = "ADDRESSBOOK"
# keys[0x1ae] = "MESSENGER"
# keys[0x1af] = "DISPLAYTOGGLE"
#define KEY_BRIGHTNESS_TOGGLE KEY_DISPLAYTOGGLE
# keys[0x1b0] = "SPELLCHECK"
# keys[0x1b1] = "LOGOFF"
# keys[0x1b2] = "DOLLAR"
# keys[0x1b3] = "EURO"
# keys[0x1b4] = "FRAMEBACK"
# keys[0x1b5] = "FRAMEFORWARD"
# keys[0x1b6] = "CONTEXT_MENU"
# keys[0x1b7] = "MEDIA_REPEAT"
# keys[0x1b8] = "10CHANNELSUP"
# keys[0x1b9] = "10CHANNELSDOWN"
# keys[0x1ba] = "IMAGES"
# keys[0x1c0] = "DEL_EOL"
# keys[0x1c1] = "DEL_EOS"
# keys[0x1c2] = "INS_LINE"
# keys[0x1c3] = "DEL_LINE"
# keys[0x1d0] = "FN"
# keys[0x1d1] = "FN_ESC"
# keys[0x1d2] = "FN_F1"
# keys[0x1d3] = "FN_F2"
# keys[0x1d4] = "FN_F3"
# keys[0x1d5] = "FN_F4"
# keys[0x1d6] = "FN_F5"
# keys[0x1d7] = "FN_F6"
# keys[0x1d8] = "FN_F7"
# keys[0x1d9] = "FN_F8"
# keys[0x1da] = "FN_F9"
# keys[0x1db] = "FN_F10"
# keys[0x1dc] = "FN_F11"
# keys[0x1dd] = "FN_F12"
# keys[0x1de] = "FN_1"
# keys[0x1df] = "FN_2"
# keys[0x1e0] = "FN_D"
# keys[0x1e1] = "FN_E"
# keys[0x1e2] = "FN_F"
# keys[0x1e3] = "FN_S"
# keys[0x1e4] = "FN_B"
# keys[0x1f1] = "BRL_DOT1"
# keys[0x1f2] = "BRL_DOT2"
# keys[0x1f3] = "BRL_DOT3"
# keys[0x1f4] = "BRL_DOT4"
# keys[0x1f5] = "BRL_DOT5"
# keys[0x1f6] = "BRL_DOT6"
# keys[0x1f7] = "BRL_DOT7"
# keys[0x1f8] = "BRL_DOT8"
# keys[0x1f9] = "BRL_DOT9"
# keys[0x1fa] = "BRL_DOT10"
# keys[0x200] = "NUMERIC_0"
# keys[0x201] = "NUMERIC_1"
# keys[0x202] = "NUMERIC_2"
# keys[0x203] = "NUMERIC_3"
# keys[0x204] = "NUMERIC_4"
# keys[0x205] = "NUMERIC_5"
# keys[0x206] = "NUMERIC_6"
# keys[0x207] = "NUMERIC_7"
# keys[0x208] = "NUMERIC_8"
# keys[0x209] = "NUMERIC_9"
# keys[0x20a] = "NUMERIC_STAR"
# keys[0x20b] = "NUMERIC_POUND"
# keys[0x20c] = "NUMERIC_A"
# keys[0x20d] = "NUMERIC_B"
# keys[0x20e] = "NUMERIC_C"
# keys[0x20f] = "NUMERIC_D"
# keys[0x210] = "CAMERA_FOCUS"
# keys[0x211] = "WPS_BUTTON"
# keys[0x212] = "TOUCHPAD_TOGGLE"
# keys[0x213] = "TOUCHPAD_ON"
# keys[0x214] = "TOUCHPAD_OFF"
# keys[0x215] = "CAMERA_ZOOMIN"
# keys[0x216] = "CAMERA_ZOOMOUT"
# keys[0x217] = "CAMERA_UP"
# keys[0x218] = "CAMERA_DOWN"
# keys[0x219] = "CAMERA_LEFT"
# keys[0x21a] = "CAMERA_RIGHT"
# keys[0x21b] = "ATTENDANT_ON"
# keys[0x21c] = "ATTENDANT_OFF"
# keys[0x21d] = "ATTENDANT_TOGGLE"
# keys[0x21e] = "LIGHTS_TOGGLE"
#define BTN_DPAD_UP 0x220
#define BTN_DPAD_DOWN 0x221
#define BTN_DPAD_LEFT 0x222
#define BTN_DPAD_RIGHT 0x223
# keys[0x230] = "ALS_TOGGLE"
# keys[0x231] = "ROTATE_LOCK_TOGGLE"
# keys[0x240] = "BUTTONCONFIG"
# keys[0x241] = "TASKMANAGER"
# keys[0x242] = "JOURNAL"
# keys[0x243] = "CONTROLPANEL"
# keys[0x244] = "APPSELECT"
# keys[0x245] = "SCREENSAVER"
# keys[0x246] = "VOICECOMMAND"
# keys[0x247] = "ASSISTANT"
# keys[0x250] = "BRIGHTNESS_MIN"
# keys[0x251] = "BRIGHTNESS_MAX"
# keys[0x260] = "KBDINPUTASSIST_PREV"
# keys[0x261] = "KBDINPUTASSIST_NEXT"
# keys[0x262] = "KBDINPUTASSIST_PREVGROUP"
# keys[0x263] = "KBDINPUTASSIST_NEXTGROUP"
# keys[0x264] = "KBDINPUTASSIST_ACCEPT"
# keys[0x265] = "KBDINPUTASSIST_CANCEL"
# Diagonal movement keys
# keys[0x266] = "RIGHT_UP"
# keys[0x267] = "RIGHT_DOWN"
# keys[0x268] = "LEFT_UP"
# keys[0x269] = "LEFT_DOWN"
# keys[0x26a] = "ROOT_MENU"
# Show Top Menu of the Media (e.g. DVD) */
# keys[0x26b] = "MEDIA_TOP_MENU"
# keys[0x26c] = "NUMERIC_11"
# keys[0x26d] = "NUMERIC_12"
#
# "Toggle Audio Description: refers to an audio service that helps blind and
# visually impaired consumers understand the action in a program. Note: in
# some countries this is referred to as "Video Description"."
#
# keys[0x26e] = "AUDIO_DESC"
# keys[0x26f] = "3D_MODE"
# keys[0x270] = "NEXT_FAVORITE"
# keys[0x271] = "STOP_RECORD"
# keys[0x272] = "PAUSE_RECORD"
# keys[0x273] = "VOD"
# keys[0x274] = "UNMUTE"
# keys[0x275] = "FASTREVERSE"
# keys[0x276] = "SLOWREVERSE"
###
# "Control a data application associated with the currently viewed channel,
# e.g. teletext or data broadcast application (MHEG, MHP, HbbTV, etc.)"
###
# keys[0x277] = "DATA"
# keys[0x278] = "ONSCREEN_KEYBOARD"
# WHAT ARE THESE:
#define BTN_TRIGGER_HAPPY 0x2c0
#define BTN_TRIGGER_HAPPY1 0x2c0
#define BTN_TRIGGER_HAPPY2 0x2c1
#define BTN_TRIGGER_HAPPY3 0x2c2
#define BTN_TRIGGER_HAPPY4 0x2c3
#define BTN_TRIGGER_HAPPY5 0x2c4
#define BTN_TRIGGER_HAPPY6 0x2c5
#define BTN_TRIGGER_HAPPY7 0x2c6
#define BTN_TRIGGER_HAPPY8 0x2c7
#define BTN_TRIGGER_HAPPY9 0x2c8
#define BTN_TRIGGER_HAPPY10 0x2c9
#define BTN_TRIGGER_HAPPY11 0x2ca
#define BTN_TRIGGER_HAPPY12 0x2cb
#define BTN_TRIGGER_HAPPY13 0x2cc
#define BTN_TRIGGER_HAPPY14 0x2cd
#define BTN_TRIGGER_HAPPY15 0x2ce
#define BTN_TRIGGER_HAPPY16 0x2cf
#define BTN_TRIGGER_HAPPY17 0x2d0
#define BTN_TRIGGER_HAPPY18 0x2d1
#define BTN_TRIGGER_HAPPY19 0x2d2
#define BTN_TRIGGER_HAPPY20 0x2d3
#define BTN_TRIGGER_HAPPY21 0x2d4
#define BTN_TRIGGER_HAPPY22 0x2d5
#define BTN_TRIGGER_HAPPY23 0x2d6
#define BTN_TRIGGER_HAPPY24 0x2d7
#define BTN_TRIGGER_HAPPY25 0x2d8
#define BTN_TRIGGER_HAPPY26 0x2d9
#define BTN_TRIGGER_HAPPY27 0x2da
#define BTN_TRIGGER_HAPPY28 0x2db
#define BTN_TRIGGER_HAPPY29 0x2dc
#define BTN_TRIGGER_HAPPY30 0x2dd
#define BTN_TRIGGER_HAPPY31 0x2de
#define BTN_TRIGGER_HAPPY32 0x2df
#define BTN_TRIGGER_HAPPY33 0x2e0
#define BTN_TRIGGER_HAPPY34 0x2e1
#define BTN_TRIGGER_HAPPY35 0x2e2
#define BTN_TRIGGER_HAPPY36 0x2e3
#define BTN_TRIGGER_HAPPY37 0x2e4
#define BTN_TRIGGER_HAPPY38 0x2e5
#define BTN_TRIGGER_HAPPY39 0x2e6
#define BTN_TRIGGER_HAPPY40 0x2e7
# We avoid low common keys in module aliases so they don't get huge.
#define KEY_MIN_INTERESTING KEY_MUTE # From original c code
# i.e. KEY_MUTE is the minimum interesting one
# Have no idea if this is correct
# NOTE: Should be 0x300
keys[MAX_KEY_MAPS - 1] = None # MAX keys is 0x2ff
#define KEY_CNT (KEY_MAX+1) # No ides what this is | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/util/keyboard_map.py | keyboard_map.py |
import asyncio
from os import path, listdir, getcwd, system
import colorful
from ..util.constants import KEYBOARDS_PATH_BASE, KEYBOARD_EVENT_FORMAT, KEYBOARD_EVENT_SIZE, SCRIPTS_ROOT, MODULE_NAME
from ..util.logger import Logger
from ..util.config import load_config
from ..watcher import AsyncKeyboard as AsyncKeyboardWatcher
logger = Logger("detect")
# Function to add keyboards (s is emphasised) from config
def add_keyboards(config):
for key, value in config["keyboards"].items():
logger.info("Running script to add keyboard for keyboard " + colorful.cyan(key) + "...")
print("") # Padding
system("cd " + getcwd() + " && python3 -m " + MODULE_NAME + " add " + key)
print("") # Padding
def add_keyboard(name, gen_handler, inputs_path):
# Check if paths not given
config = load_config()
if name == "" or name not in config["keyboards"]:
logger.warn("No keyboard supplied.")
logger.warn("Detection will be ran on all keyboards.")
logger.warn("To just generate daemons, use the 'daemon-gen' command")
logger.info("Running detection on all keyboards...")
return add_keyboards(config)
logger.info("Mapping keyboard " + name)
logger.info("Scanning for keyboards...")
if not path.isdir(inputs_path): # Make sure there's something to detect
logger.err("Couldn't scan for keyboards")
logger.err("Verify you have at least one keyboard plugged in")
logger.err("and the dir " + inputs_path + " exists")
logger.err("You can specify a custom path with the --inputs-path option")
exit()
# Scan
# From https://stackoverflow.com/questions/3207219/how-do-i-list-all-files-of-a-directory
keyboards = listdir(inputs_path)
logger.debug("Keyboards:")
logger.debug(keyboards)
logger.info("Press a button on the keyboard you want to map to register it.")
# Then watch all keyboards and ask for one to be pressed
keyboards_events = [AsyncKeyboardWatcher(keyboard_path, inputs_path) for keyboard_path in keyboards] # Keyboard watch classes for each input
handler = gen_handler(keyboards_events, name) # The handler needs access to keyboards_events, which it won't on exe in the watcher, as well as keyboard name
# Run
jobs = [keyboards_events[i].keyboard_watcher(handler) for i in range(0, len(keyboards))] # Create jobs list
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(jobs)) | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/add_keyboard/add_keyboard.py | add_keyboard.py |
from .add_keyboard import add_keyboard
import sys
import os
import signal
import aiofiles
from ..util import Logger
import yaml
from .sync_keyboard_path import update_server_keyboard_path
logger = Logger("add")
PID = os.getpid()
# IMPORTANT: Don't use non async functions in this. That includes the logger
# EXCEPTIONS ARE NOT CAUGHT
def gen_async_handler(keyboards, keyboard_name):
async def handler(keyboard):
print("[DEBUG] STOPPING WATCH")
# Stop each keyboard object one by one, then write config
for keyboard_stop in keyboards:
print("[DEBUG] ROOT: STOPPING " + keyboard_stop.keyboard)
await keyboard_stop.stop_watch()
# Write config
logger.info("Writing keyboard " + keyboard + " as " + keyboard_name)
logger.debug("Opening config...")
# 1: Open current file for updating
async with aiofiles.open(os.getcwd() + "/config.yml", mode="r") as config_file:
logger.debug("ASYNC FILE OPS") # DEBUG: signal start of async file ops, so as to help detect where program breaks
config_contents = await config_file.read() # Read config
logger.debug("Contents:\n" + config_contents)
# Parse it into python obj
config = yaml.load(config_contents, Loader=yaml.FullLoader)
logger.debug("Parsed contents: " + str(config))
config["keyboards"][keyboard_name]["path"] = keyboard # Update keyboard with path in /dev/input
logger.debug("Writing config...")
# r+ appends, so we have to create a new stream so we cam write
async with aiofiles.open("config.yml", mode="w") as config_write:
await config_write.write("# Config for 2Keys\n# ONLY FOR USE BY THE PROGRAM\n# To change the config, update it on the client and run \"2Keys config-update\" here\n" +
yaml.dump(config, default_flow_style=False)) # Write it
await config_write.close() # Close so other programs can use
logger.info("Config writen.")
logger.info("Updating path on server....")
await update_server_keyboard_path(keyboard_name, keyboard)
os.kill(PID, signal.SIGTERM) # Exit() does't work, so we have to self kill the script
exit() # So only one ^C is needed to end the program
return
return handler | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/add_keyboard/async_handler.py | async_handler.py |
import sys
import os
import stat
import pystache
from ..util.logger import Logger
from ..util.constants import DAEMON_TEMPLATE_PATH, SCRIPTS_ROOT, LOCAL_ROOT, DAEMON_TEMPLATE_SCRIPT_PATH
logger = Logger("daemon")
# Generates a systemd unit file
# Name: Name of 2Keys project
# Keyboards: Array of keyboard names
def generate_daemon(name, keyboards):
logger.info("Creating systemd unit scripts...")
template = open(DAEMON_TEMPLATE_PATH, "r").read() # Open template
for keyboard in keyboards:
script = pystache.render(template, {
"name": name,
"index_path": "2Keys",
"keyboard": keyboard,
"detector_path": SCRIPTS_ROOT,
"version": str(sys.version_info[0]) + "." + str(sys.version_info[1]),
"pwd": os.getcwd()
})
if not os.path.exists(LOCAL_ROOT):
logger.info("Making local root ./.2Keys...")
os.makedirs(LOCAL_ROOT)
UNIT_FILE_NAME = "2Keys-%s.service" % keyboard
logger.info("Creating unit file {}...".format(UNIT_FILE_NAME))
unitFile = open(LOCAL_ROOT + "/" + UNIT_FILE_NAME, "w")
logger.info("Writing...")
unitFile.write(script)
logger.info("Writing a shell script to manage the unit files (services/daemons)...")
shTemplate = open(DAEMON_TEMPLATE_SCRIPT_PATH, "r").read()
keyboard_string = "("
# Create array of keyboards
for keyboard in keyboards:
keyboard_string += keyboard + " "
# End array
keyboard_string = keyboard_string[0:-1] + ")"
# Render mustache template
shScript = pystache.render(shTemplate, {
"keyboards": keyboard_string
})
shScriptFile = open(LOCAL_ROOT + "/register.sh", "w")
shScriptFile.write(shScript)
logger.info("Making executable...")
# From https://stackoverflow.com/questions/12791997/how-do-you-do-a-simple-chmod-x-from-within-python
st = os.stat(LOCAL_ROOT + "/register.sh")
os.chmod(LOCAL_ROOT + "/register.sh", st.st_mode | stat.S_IEXEC)
logger.info("")
logger.info("Generated unit files to start 2Keys on startup!")
logger.info("To install the services for use, please run:")
logger.info(" sudo bash ./.2Keys/register.sh register")
logger.info("For help on how to use the script:")
logger.info(" sudo bash ./.2Keys/register.sh help") | 2Keys | /2Keys-0.5.1.tar.gz/2Keys-0.5.1/twokeys/daemon/scripts.py | scripts.py |
import enum
from typing import Tuple
USAGE = """\
i2w <x> <z>: convert coordinate in 8K radar image to the corresponding coordinate in 2b2t world
image2world <x> <z>: convert coordinate in 8K radar image to the corresponding coordinate in 2b2t world
w2i <x> <z>: convert coordinate in 2b2t world to the corresponding coordinate in 8K radar image
world2image <x> <z>: convert coordinate in 2b2t world to the corresponding coordinate in 8K radar image
q (or quit, exit): exit program
h (or help): show this help menu\
"""
class RadarImageType(enum.Enum):
RADAR_4K = (3840, 2160, 8)
RADAR_8K = (7680, 4320, 4)
def world_to_image(loc, image_type=RadarImageType.RADAR_8K) -> Tuple[int, int]:
"""
Given a coordinate in 2b2t overworld, return the corresponding pixel coordinate in radar image.
"""
x, z = loc
off_x, off_z, chunks_per_pixel = image_type.value[0] // 2, image_type.value[1] // 2, image_type.value[2]
return 3840 + x // 16 // chunks_per_pixel, 2160 + z // 16 // chunks_per_pixel
def image_to_world(loc, image_type=RadarImageType.RADAR_8K) -> Tuple[int, int]:
"""
Given a position in radar image, return the center coordinate of the corresponding range in 2b2t overworld.
"""
x, z = loc
off_x, off_z, chunks_per_pixel = image_type.value[0] // 2, image_type.value[1] // 2, image_type.value[2]
x, z = x - off_x, z - off_z
return int((x + 0.5) * 16 * chunks_per_pixel), int((z + 0.5) * 16 * chunks_per_pixel)
def main():
""" REPL """
while True:
try:
inp = input('> ').strip().split(' ') or None
cmd = inp[0] if len(inp) > 0 else None
if cmd == 'i2w' or cmd == 'image2world':
world_x, world_y = image_to_world((int(inp[1]), int(inp[2])))
print(f'World: ({world_x}, {world_y})')
print(f'Nether: ({world_x // 8}, {world_y // 8})')
elif cmd == 'w2i' or cmd == 'world2image':
print(world_to_image((int(inp[1]), int(inp[2]))))
elif cmd == 'q' or cmd == 'quit' or cmd == 'exit':
break
elif cmd == 'h' or cmd == 'help':
print(USAGE)
elif not cmd:
pass
else:
print('Invalid command. Run \'help\' or \'h\' for usage description.')
except (ValueError, IndexError):
print('Invalid command. Type `help` or `h` for help.')
except KeyboardInterrupt:
print()
pass # Ignore Ctrl-C event
if __name__ == '__main__':
main() | 2b2t | /2b2t-0.3.0.tar.gz/2b2t-0.3.0/bbtt/coord/__main__.py | __main__.py |
# 2b2t.py
This package handles all things 2b2t!
## Installation
You can install the package with pip.
```
pip install 2b2t
```
or
```
pip3 install 2b2t
```
Or you can install with GitHub
1. Clone the repo
2. Run setup.py
3. Install Python3 if you don't already have it
4. Install requests and colorama if you don't already have it
```
git clone https://github.com/BGP0/2b2t.py.git
python3 setup.py build install
pip3 install requests
pip3 install colorama
```
## Usage
[Docs](https://github.com/BGP0/2b2t.py/wiki)
## Credits
Orginal Software made by BGP
Thanks to SkilzMastr for turning the checker into a package!
| 2b2t.py | /2b2t.py-1.7.6.tar.gz/2b2t.py-1.7.6/README.md | README.md |
import requests
from colorama import Fore, init
import threading
class listCheck():
def __init__(self, usernames, printOut=False):
self.usernames = usernames
self.printOut = printOut
init(convert=True)
def listBased(self, usernameList):
for username in usernameList:
self.check(username)
def check(self, username):
data = f'ign={username}'
headers = {
'Content-Type': 'application/x-www-form-urlencoded'
}
request = requests.request('POST', "https://donate.2b2t.org/category/738999", data=data, headers=headers)
if self.printOut:
if 'rate limited' in request.text:
print(Fore.LIGHTMAGENTA_EX + f"YOU'VE BEEN RATELIMITED!! :(")
elif 'not a valid' in request.text:
print(Fore.LIGHTRED_EX + f"{username} is not a valid username")
elif 'Unable' in request.text:
print(Fore.LIGHTRED_EX + f"Unable to find a player with the username: {input}")
elif 'banned' not in request.text:
print(Fore.LIGHTRED_EX + f"{username} is not currently banned")
else:
print(Fore.LIGHTGREEN_EX + f"{username} is currently banned")
else:
if 'rate limited' in request.text:
return 0
elif 'not a valid' in request.text:
return 1
elif 'Unable' in request.text:
return 2
elif 'banned' not in request.text:
return False
else:
return True
def l1(self):
for i in range(len(self.lines1)):
self.check(self.lines1[i])
def l2(self):
for i in range(len(self.lines2)):
self.check(self.lines2[i])
def start(self):
if self.usernames is list:
self.listBased(self.usernames)
else:
self.lines = [item.replace("\n", "") for item in open(self.usernames, 'r').readlines()]
self.lines1 = self.lines[:len(self.lines)//2]
self.lines2 = self.lines[len(self.lines)//2:]
self.threads = []
self.t1 = threading.Thread(target=self.l1)
self.t2 = threading.Thread(target=self.l2)
self.threads.append(self.t1)
self.threads.append(self.t2)
self.t1.start()
self.t2.start()
print(('\nFinished loading all threads.\n').center(119))
for x in self.threads:
x.join()
input(Fore.RESET + 'Finished Checking!') | 2b2t.py | /2b2t.py-1.7.6.tar.gz/2b2t.py-1.7.6/py2b/listCheck.py | listCheck.py |
# Python Module for 2Captcha API
The easiest way to quickly integrate [2Captcha] captcha solving service into your code to automate solving of any types of captcha.
- [Python Module for 2Captcha API](#python-module-for-2captcha-api)
- [Installation](#installation)
- [Configuration](#configuration)
- [TwoCaptcha instance options](#twocaptcha-instance-options)
- [Solve captcha](#solve-captcha)
- [Captcha options](#captcha-options)
- [Normal Captcha](#normal-captcha)
- [Text Captcha](#text-captcha)
- [ReCaptcha v2](#recaptcha-v2)
- [ReCaptcha v3](#recaptcha-v3)
- [FunCaptcha](#funcaptcha)
- [GeeTest](#geetest)
- [hCaptcha](#hcaptcha)
- [GeeTest v4](#geetest-v4)
- [Lemin Cropped Captcha](#lemin-cropped-captcha)
- [Cloudflare Turnstile](#cloudflare-turnstile)
- [Amazon WAF](#amazon-waf)
- [KeyCaptcha](#keycaptcha)
- [Capy](#capy)
- [Grid](#grid)
- [Canvas](#canvas)
- [ClickCaptcha](#clickcaptcha)
- [Rotate](#rotate)
- [Other methods](#other-methods)
- [send / getResult](#send--getresult)
- [balance](#balance)
- [report](#report)
- [Error handling](#error-handling)
- [Proxies](#proxies)
- [Async calls](#async-calls)
## Installation
This package can be installed with Pip:
```pip3 install 2captcha-python```
## Configuration
TwoCaptcha instance can be created like this:
```python
from twocaptcha import TwoCaptcha
solver = TwoCaptcha('YOUR_API_KEY')
```
Also there are few options that can be configured:
```python
config = {
'server': '2captcha.com',
'apiKey': 'YOUR_API_KEY',
'softId': 123,
'callback': 'https://your.site/result-receiver',
'defaultTimeout': 120,
'recaptchaTimeout': 600,
'pollingInterval': 10,
}
solver = TwoCaptcha(**config)
```
### TwoCaptcha instance options
| Option | Default value | Description |
| ---------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| server | `2captcha.com` | API server. You can set it to `rucaptcha.com` if your account is registered there |
| softId | - | your software ID obtained after publishing in [2captcha sofware catalog] |
| callback | - | URL of your web-sever that receives the captcha recognition result. The URl should be first registered in [pingback settings] of your account |
| defaultTimeout | 120 | Polling timeout in seconds for all captcha types except ReCaptcha. Defines how long the module tries to get the answer from `res.php` API endpoint |
| recaptchaTimeout | 600 | Polling timeout for ReCaptcha in seconds. Defines how long the module tries to get the answer from `res.php` API endpoint |
| pollingInterval | 10 | Interval in seconds between requests to `res.php` API endpoint, setting values less than 5 seconds is not recommended |
> **IMPORTANT:** once `callback` is defined for `TwoCaptcha` instance, all methods return only the captcha ID and DO NOT poll the API to get the result. The result will be sent to the callback URL.
To get the answer manually use [getResult method](#send--getresult)
## Solve captcha
When you submit any image-based captcha use can provide additional options to help 2captcha workers to solve it properly.
### Captcha options
| Option | Default Value | Description |
| ------------- | ------------- | -------------------------------------------------------------------------------------------------- |
| numeric | 0 | Defines if captcha contains numeric or other symbols [see more info in the API docs][post options] |
| minLen | 0 | minimal answer lenght |
| maxLen | 0 | maximum answer length |
| phrase | 0 | defines if the answer contains multiple words or not |
| caseSensitive | 0 | defines if the answer is case sensitive |
| calc | 0 | defines captcha requires calculation |
| lang | - | defines the captcha language, see the [list of supported languages] |
| hintImg | - | an image with hint shown to workers with the captcha |
| hintText | - | hint or task text shown to workers with the captcha |
Below you can find basic examples for every captcha type. Check out [examples directory] to find more examples with all available options.
### Normal Captcha
To bypass a normal captcha (distorted text on image) use the following method. This method also can be used to recognize any text on the image.
```python
result = solver.normal('path/to/captcha.jpg', param1=..., ...)
# OR
result = solver.normal('https://site-with-captcha.com/path/to/captcha.jpg', param1=..., ...)
```
### Text Captcha
This method can be used to bypass a captcha that requires to answer a question provided in clear text.
```python
result = solver.text('If tomorrow is Saturday, what day is today?', param1=..., ...)
```
### ReCaptcha v2
Use this method to solve ReCaptcha V2 and obtain a token to bypass the protection.
```python
result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
url='https://mysite.com/page/with/recaptcha',
param1=..., ...)
```
### ReCaptcha v3
This method provides ReCaptcha V3 solver and returns a token.
```python
result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
url='https://mysite.com/page/with/recaptcha',
version='v3',
param1=..., ...)
```
### FunCaptcha
FunCaptcha (Arkoselabs) solving method. Returns a token.
```python
result = solver.funcaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
url='https://mysite.com/page/with/funcaptcha',
param1=..., ...)
```
### GeeTest
Method to solve GeeTest puzzle captcha. Returns a set of tokens as JSON.
```python
result = solver.geetest(gt='f1ab2cdefa3456789012345b6c78d90e',
challenge='12345678abc90123d45678ef90123a456b',
url='https://www.site.com/page/',
param1=..., ...)
```
### hCaptcha
Use this method to solve hCaptcha challenge. Returns a token to bypass captcha.
```python
result = solver.hcaptcha(sitekey='10000000-ffff-ffff-ffff-000000000001',
url='https://www.site.com/page/',
param1=..., ...)
```
### GeeTest v4
Use this method to solve GeeTest v4. Returns the response in JSON.
```python
result = solver.geetest_v4(captcha_id='e392e1d7fd421dc63325744d5a2b9c73',
url='https://www.site.com/page/',
param1=..., ...)
```
### Lemin Cropped Captcha
Use this method to solve hCaptcha challenge. Returns JSON with answer containing the following values: answer, challenge_id.
```python
result = solver.lemin(captcha_id='CROPPED_1abcd2f_a1234b567c890d12ef3a456bc78d901d',
div_id='lemin-cropped-captcha',
url='https://www.site.com/page/',
param1=..., ...)
```
### Cloudflare Turnstile
Use this method to solve Cloudflare Turnstile. Returns JSON with the token.
```python
result = solver.turnstile(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
url='http://mysite.com/',
param1=..., ...)
```
### Amazon WAF
Use this method to solve Amazon WAF Captcha also known as AWS WAF Captcha is a part of Intelligent threat mitigation for Amazon AWS. Returns JSON with the token.
```python
result = solver.amazon_waf(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
iv='CgAHbCe2GgAAAAAj',
context='9BUgmlm48F92WUoqv97a49ZuEJJ50TCk9MVr3C7WMtQ0X6flVbufM4n8mjFLmbLVAPgaQ1Jydeaja94iAS49ljb+sUNLoukWedAQZKrlY4RdbOOzvcFqmD/ZepQFS9N5w15Exr4VwnVq+HIxTsDJwRviElWCdzKDebN/mk8/eX2n7qJi5G3Riq0tdQw9+C4diFZU5E97RSeahejOAAJTDqduqW6uLw9NsjJBkDRBlRjxjn5CaMMo5pYOxYbGrM8Un1JH5DMOLeXbq1xWbC17YSEoM1cRFfTgOoc+VpCe36Ai9Kc='
url='https://non-existent-example.execute-api.us-east-1.amazonaws.com/latest'
param1=..., ...)
```
### KeyCaptcha
Token-based method to solve KeyCaptcha.
```python
result = solver.keycaptcha(s_s_c_user_id=10,
s_s_c_session_id='493e52c37c10c2bcdf4a00cbc9ccd1e8',
s_s_c_web_server_sign='9006dc725760858e4c0715b835472f22-pz-',
s_s_c_web_server_sign2='2ca3abe86d90c6142d5571db98af6714',
url='https://www.keycaptcha.ru/demo-magnetic/',
param1=..., ...)
```
### Capy
Token-based method to bypass Capy puzzle captcha.
```python
result = solver.capy(sitekey='PUZZLE_Abc1dEFghIJKLM2no34P56q7rStu8v',
url='http://mysite.com/',
api_server='https://jp.api.capy.me/',
param1=..., ...)
```
### Grid
Grid method is originally called Old ReCaptcha V2 method. The method can be used to bypass any type of captcha where you can apply a grid on image and need to click specific grid boxes. Returns numbers of boxes.
```python
result = solver.grid('path/to/captcha.jpg', param1=..., ...)
```
### Canvas
Canvas method can be used when you need to draw a line around an object on image. Returns a set of points' coordinates to draw a polygon.
```python
result = solver.canvas('path/to/captcha.jpg', param1=..., ...)
```
### ClickCaptcha
ClickCaptcha method returns coordinates of points on captcha image. Can be used if you need to click on particular points on the image.
```python
result = solver.coordinates('path/to/captcha.jpg', param1=..., ...)
```
### Rotate
This method can be used to solve a captcha that asks to rotate an object. Mostly used to bypass FunCaptcha. Returns the rotation angle.
```python
result = solver.rotate('path/to/captcha.jpg', param1=..., ...)
```
## Other methods
### send / getResult
These methods can be used for manual captcha submission and answer polling.
```python
import time
. . . . .
id = solver.send(file='path/to/captcha.jpg')
time.sleep(20)
code = solver.get_result(id)
```
### balance
Use this method to get your account's balance
```python
balance = solver.balance()
```
### report
Use this method to report good or bad captcha answer.
```python
solver.report(id, True) # captcha solved correctly
solver.report(id, False) # captcha solved incorrectly
```
### Error handling
In case of an error, the captcha solver throws an exception. It's important to properly handle these cases. We recommend using `try except` to handle exceptions.
```python
try:
result = solver.text('If tomorrow is Saturday, what day is today?')
except ValidationException as e:
# invalid parameters passed
print(e)
except NetworkException as e:
# network error occurred
print(e)
except ApiException as e:
# api respond with error
print(e)
except TimeoutException as e:
# captcha is not solved so far
print(e)
```
### Proxies
You can pass your proxy as an additional argument for methods: recaptcha, funcaptcha and geetest. The proxy will be forwarded to the API to solve the captcha.
```python
proxy={
'type': 'HTTPS',
'uri': 'login:password@IP_address:PORT'
}
```
### Async calls
You can also make async calls with [asyncio], for example:
```python
import asyncio
import concurrent.futures
from twocaptcha import TwoCaptcha
captcha_result = await captchaSolver(image)
async def captchaSolver(image):
loop = asyncio.get_running_loop()
with concurrent.future.ThreadPoolExecutor() as pool:
result = await loop.run_in_executor(pool, lambda: TwoCaptcha(API_KEY).normal(image))
return result
```
[2Captcha]: https://2captcha.com/
[2captcha sofware catalog]: https://2captcha.com/software
[pingback settings]: https://2captcha.com/setting/pingback
[post options]: https://2captcha.com/2captcha-api#normal_post
[list of supported languages]: https://2captcha.com/2captcha-api#language
[examples directory]: /examples
[asyncio]: https://docs.python.org/3/library/asyncio.html
| 2captcha-python | /2captcha-python-1.2.1.tar.gz/2captcha-python-1.2.1/README.md | README.md |
import os, sys
import time
import requests
from base64 import b64encode
try:
from .api import ApiClient
except ImportError:
from api import ApiClient
class SolverExceptions(Exception):
pass
class ValidationException(SolverExceptions):
pass
class NetworkException(SolverExceptions):
pass
class ApiException(SolverExceptions):
pass
class TimeoutException(SolverExceptions):
pass
class TwoCaptcha():
def __init__(self,
apiKey,
softId=None,
callback=None,
defaultTimeout=120,
recaptchaTimeout=600,
pollingInterval=10,
server = '2captcha.com'):
self.API_KEY = apiKey
self.soft_id = softId
self.callback = callback
self.default_timeout = defaultTimeout
self.recaptcha_timeout = recaptchaTimeout
self.polling_interval = pollingInterval
self.api_client = ApiClient(post_url = str(server))
self.max_files = 9
self.exceptions = SolverExceptions
def normal(self, file, **kwargs):
'''
Wrapper for solving normal captcha (image)
Required:
file (image, base64, or url)
Optional params:
phrase
numeric
minLen
maxLen
phrase
caseSensitive
calc
lang
hintText
hintImg
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
method = self.get_method(file)
result = self.solve(**method, **kwargs)
return result
def text(self, text, **kwargs):
'''
Wrapper for solving text captcha
Required:
text
Optional params:
lang
softId
callback
'''
result = self.solve(text=text, method='post', **kwargs)
return result
def recaptcha(self, sitekey, url, version='v2', enterprise=0, **kwargs):
'''
Wrapper for solving recaptcha (v2, v3)
Required:
sitekey
url
Optional params:
invisible
version
enterprise
action
score
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
params = {
'googlekey': sitekey,
'url': url,
'method': 'userrecaptcha',
'version': version,
'enterprise': enterprise,
**kwargs,
}
result = self.solve(timeout=self.recaptcha_timeout, **params)
return result
def funcaptcha(self, sitekey, url, **kwargs):
'''
Wrapper for solving funcaptcha
Required:
sitekey
url
Optional params:
surl
userAgent
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
**{'data[key]': 'anyStringValue'}
'''
result = self.solve(publickey=sitekey,
url=url,
method='funcaptcha',
**kwargs)
return result
def geetest(self, gt, challenge, url, **kwargs):
'''
Wrapper for solving geetest captcha
Required:
gt
challenge
url
Optional params:
apiServer
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
result = self.solve(gt=gt,
challenge=challenge,
url=url,
method='geetest',
**kwargs)
return result
def hcaptcha(self, sitekey, url, **kwargs):
'''
Wrapper for solving hcaptcha
Required:
sitekey
url
Optional params:
invisible
data
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
result = self.solve(sitekey=sitekey,
url=url,
method='hcaptcha',
**kwargs)
return result
def keycaptcha(self, s_s_c_user_id, s_s_c_session_id,
s_s_c_web_server_sign, s_s_c_web_server_sign2, url,
**kwargs):
'''
Wrapper for solving
Required:
s_s_c_user_id
s_s_c_session_id
s_s_c_web_server_sign
s_s_c_web_server_sign2
url
Optional params:
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
params = {
's_s_c_user_id': s_s_c_user_id,
's_s_c_session_id': s_s_c_session_id,
's_s_c_web_server_sign': s_s_c_web_server_sign,
's_s_c_web_server_sign2': s_s_c_web_server_sign2,
'url': url,
'method': 'keycaptcha',
**kwargs,
}
result = self.solve(**params)
return result
def capy(self, sitekey, url, **kwargs):
'''
Wrapper for solving capy
Required:
sitekey
url
Optional params:
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
result = self.solve(captchakey=sitekey,
url=url,
method='capy',
**kwargs)
return result
def grid(self, file, **kwargs):
'''
Wrapper for solving grid captcha (image)
Required:
file (image or base64)
Optional params:
rows
cols
previousId
canSkip
lang
hintImg
hintText
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
method = self.get_method(file)
params = {
'recaptcha': 1,
**method,
**kwargs,
}
result = self.solve(**params)
return result
def canvas(self, file, **kwargs):
'''
Wrapper for solving canvas captcha (image)
Required:
file (image or base64)
Optional params:
previousId
canSkip
lang
hintImg
hintText
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
if not ('hintText' in kwargs or 'hintImg' in kwargs):
raise ValidationException(
'parameters required: hintText and/or hintImg')
method = self.get_method(file)
params = {
'recaptcha': 1,
'canvas': 1,
**method,
**kwargs,
}
result = self.solve(**params)
return result
def coordinates(self, file, **kwargs):
'''
Wrapper for solving coordinates captcha (image)
Required:
file (image or base64)
Optional params:
hintImg
hintText
lang
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
method = self.get_method(file)
params = {
'coordinatescaptcha': 1,
**method,
**kwargs,
}
result = self.solve(**params)
return result
def rotate(self, files, **kwargs):
'''
Wrapper for solving rotate captcha (image)
Required:
files (images)
Optional params:
angle
lang
hintImg
hintText
softId
callback
proxy = {'type': 'HTTPS', 'uri': 'login:password@IP_address:PORT'})
'''
if isinstance(files, str):
file = self.get_method(files)['file']
result = self.solve(file=file, method='rotatecaptcha', **kwargs)
return result
elif isinstance(files, dict):
files = list(files.values())
files = self.extract_files(files)
result = self.solve(files=files, method='rotatecaptcha', **kwargs)
return result
def geetest_v4(self, captcha_id, url, **kwargs):
'''
Wrapper for solving geetest_v4 captcha
Required:
captcha_id
url
Optional params:
'''
result = self.solve(captcha_id=captcha_id,
url=url,
method='geetest_v4',
**kwargs)
return result
def lemin(self, captcha_id, div_id, url, **kwargs):
'''
Wrapper for solving Lemin Cropped Captcha
Required:
captcha_id
div_id
url
Optional params:
'''
result = self.solve(captcha_id=captcha_id,
div_id=div_id,
url=url,
method='lemin',
**kwargs)
return result
def turnstile(self, sitekey, url, **kwargs):
'''
Wrapper for solving Cloudflare Turnstile
Required:
sitekey
url
Optional params:
action
data
'''
result = self.solve(sitekey=sitekey,
url=url,
method='turnstile',
**kwargs)
return result
def amazon_waf(self, sitekey, iv, context, url, **kwargs):
'''
Wrapper for solving Amazon WAF
Required:
sitekey
iv
context
url
Optional params:
'''
result = self.solve(sitekey=sitekey,
iv=iv,
context=context,
url=url,
method='amazon_waf',
**kwargs)
return result
def solve(self, timeout=0, polling_interval=0, **kwargs):
'''
sends captcha, receives result
Parameters
----------
timeout : float
polling_interval : int
**kwargs : all captcha params
Returns
-------
result : string
'''
id_ = self.send(**kwargs)
result = {'captchaId': id_}
if self.callback is None:
timeout = float(timeout or self.default_timeout)
sleep = int(polling_interval or self.polling_interval)
code = self.wait_result(id_, timeout, sleep)
result.update({'code': code})
return result
def wait_result(self, id_, timeout, polling_interval):
max_wait = time.time() + timeout
while time.time() < max_wait:
try:
return self.get_result(id_)
except NetworkException:
time.sleep(polling_interval)
raise TimeoutException(f'timeout {timeout} exceeded')
def get_method(self, file):
if not file:
raise ValidationException('File required')
if not '.' in file and len(file) > 50:
return {'method': 'base64', 'body': file}
if file.startswith('http'):
img_resp = requests.get(file)
if img_resp.status_code != 200:
raise ValidationException(f'File could not be downloaded from url: {file}')
return {'method': 'base64', 'body': b64encode(img_resp.content).decode('utf-8')}
if not os.path.exists(file):
raise ValidationException(f'File not found: {file}')
return {'method': 'post', 'file': file}
def send(self, **kwargs):
params = self.default_params(kwargs)
params = self.rename_params(params)
params, files = self.check_hint_img(params)
response = self.api_client.in_(files=files, **params)
if not response.startswith('OK|'):
raise ApiException(f'cannot recognize response {response}')
return response[3:]
def get_result(self, id_):
response = self.api_client.res(key=self.API_KEY, action='get', id=id_)
if response == 'CAPCHA_NOT_READY':
raise NetworkException
if not response.startswith('OK|'):
raise ApiException(f'cannot recognize response {response}')
return response[3:]
def balance(self):
'''
get my balance
Returns
-------
balance : float
'''
response = self.api_client.res(key=self.API_KEY, action='getbalance')
return float(response)
def report(self, id_, correct):
'''
report of solved captcha: good/bad
Parameters
----------
id_ : captcha ID
correct : True/False
Returns
-------
None.
'''
rep = 'reportgood' if correct else 'reportbad'
self.api_client.res(key=self.API_KEY, action=rep, id=id_)
return
def rename_params(self, params):
replace = {
'caseSensitive': 'regsense',
'minLen': 'min_len',
'maxLen': 'max_len',
'minLength': 'min_len',
'maxLength': 'max_len',
'hintText': 'textinstructions',
'hintImg': 'imginstructions',
'url': 'pageurl',
'score': 'min_score',
'text': 'textcaptcha',
'rows': 'recaptcharows',
'cols': 'recaptchacols',
'previousId': 'previousID',
'canSkip': 'can_no_answer',
'apiServer': 'api_server',
'softId': 'soft_id',
'callback': 'pingback',
'datas': 'data-s',
}
new_params = {
v: params.pop(k)
for k, v in replace.items() if k in params
}
proxy = params.pop('proxy', '')
proxy and new_params.update({
'proxy': proxy['uri'],
'proxytype': proxy['type']
})
new_params.update(params)
return new_params
def default_params(self, params):
params.update({'key': self.API_KEY})
callback = params.pop('callback', self.callback)
soft_id = params.pop('softId', self.soft_id)
if callback: params.update({'callback': callback})
if soft_id: params.update({'softId': soft_id})
self.has_callback = bool(callback)
return params
def extract_files(self, files):
if len(files) > self.max_files:
raise ValidationException(
f'Too many files (max: {self.max_files})')
not_exists = [f for f in files if not (os.path.exists(f))]
if not_exists:
raise ValidationException(f'File not found: {not_exists}')
files = {f'file_{e+1}': f for e, f in enumerate(files)}
return files
def check_hint_img(self, params):
hint = params.pop('imginstructions', None)
files = params.pop('files', {})
if not hint:
return params, files
if not '.' in hint and len(hint) > 50:
return params, files
if not os.path.exists(hint):
raise ValidationException(f'File not found: {hint}')
if not files:
files = {'file': params.pop('file', {})}
files.update({'imginstructions': hint})
return params, files
if __name__ == '__main__':
key = sys.argv[1]
sol = TwoCaptcha(key) | 2captcha-python | /2captcha-python-1.2.1.tar.gz/2captcha-python-1.2.1/twocaptcha/solver.py | solver.py |
import requests
class NetworkException(Exception):
pass
class ApiException(Exception):
pass
class ApiClient():
def __init__(self, post_url = '2captcha.com'):
self.post_url = post_url
def in_(self, files={}, **kwargs):
'''
sends POST-request (files and/or params) to solve captcha
Parameters
----------
files : TYPE, optional
DESCRIPTION. The default is {}.
**kwargs : TYPE
DESCRIPTION.
Raises
------
NetworkException
DESCRIPTION.
ApiException
DESCRIPTION.
Returns
-------
resp : TYPE
DESCRIPTION.
'''
try:
current_url = 'https://'+self.post_url+'/in.php'
if files:
files = {key: open(path, 'rb') for key, path in files.items()}
resp = requests.post(current_url,
data=kwargs,
files=files)
[f.close() for f in files.values()]
elif 'file' in kwargs:
with open(kwargs.pop('file'), 'rb') as f:
resp = requests.post(current_url,
data=kwargs,
files={'file': f})
else:
resp = requests.post(current_url,
data=kwargs)
except requests.RequestException as e:
raise NetworkException(e)
if resp.status_code != 200:
raise NetworkException(f'bad response: {resp.status_code}')
resp = resp.content.decode('utf-8')
if 'ERROR' in resp:
raise ApiException(resp)
return resp
def res(self, **kwargs):
'''
sends additional GET-requests (solved captcha, balance, report etc.)
Parameters
----------
**kwargs : TYPE
DESCRIPTION.
Raises
------
NetworkException
DESCRIPTION.
ApiException
DESCRIPTION.
Returns
-------
resp : TYPE
DESCRIPTION.
'''
try:
current_url_out = 'https://'+self.post_url+'/res.php'
resp = requests.get(current_url_out, params=kwargs)
if resp.status_code != 200:
raise NetworkException(f'bad response: {resp.status_code}')
resp = resp.content.decode('utf-8')
if 'ERROR' in resp:
raise ApiException(resp)
except requests.RequestException as e:
raise NetworkException(e)
return resp | 2captcha-python | /2captcha-python-1.2.1.tar.gz/2captcha-python-1.2.1/twocaptcha/api.py | api.py |
# 2ch-downloader
Download all files of 2ch.hk thread.
## Installation
``` sh
pip install 2ch-downloader
```
## Usage
```
usage: 2ch-downloader [-h] [-d DIRECTORY] [--max-directory-name-length LENGTH] URL
positional arguments:
URL Thread url
options:
-h, --help show this help message and exit
-d DIRECTORY, --directory DIRECTORY
Download directory
--max-directory-name-length LENGTH
Max thread directory name length, 128 by default
```
| 2ch-downloader | /2ch-downloader-0.0.3.tar.gz/2ch-downloader-0.0.3/README.md | README.md |
__prog__ = "2ch-downloader"
__desc__ = "Download all files of 2ch.hk thread."
__version__ = "0.0.3"
import argparse
import html
import json
import os
import re
import sys
from dataclasses import dataclass
from pathlib import Path
import requests
@dataclass
class File:
name: str
url: str
size: int
id: str
def download_thread_media(url: str, path: Path, max_directory_name_length: int) -> None:
BASE_URL = "https://2ch.hk"
api_url = url.replace(".html", ".json")
response = json.loads(requests.get(api_url).text)
thread = response["threads"][0]
board = response["board"]["name"]
thread_id = int(response["current_thread"])
thread_name = html.unescape(thread["posts"][0]["subject"])
directory_name = f'{board} {thread_id} {thread_name.replace("/", "_")}'
print(f"Thread {directory_name}")
if len(directory_name) > max_directory_name_length:
directory_name = directory_name[:max_directory_name_length]
path = path / directory_name
os.makedirs(path, exist_ok=True)
os.chdir(path)
files: list[File] = []
for post in thread["posts"]:
if post["files"]:
for file in post["files"]:
basename, extension = os.path.splitext(file["name"])
files.append(
File(
file["fullname"] or f'Sticker{extension}',
BASE_URL + file["path"],
file["size"],
basename,
)
)
for file in files:
download_file(file)
def download_file(file: File) -> None:
filename = f"{file.id} {file.name}"
# Иногда ни размер файла, ни его хеш, отдаваемые api, не соответствуют действительности
# Проверять их бессмысленно
if os.path.exists(filename):
print(f"'{filename}' has already been downloaded", file=sys.stderr)
else:
print(f"Downloading '{filename}' ({file.size} KB)", file=sys.stderr)
r = requests.get(file.url)
with open(filename, "wb") as f:
f.write(r.content)
def thread_url(url: str) -> str:
thread_url_regex = re.compile(
r"(?:https?:\/\/)?2ch.hk\/[a-z]+\/res\/[0-9]+.html", flags=re.I
)
if not thread_url_regex.match(url):
raise ValueError("Provided url is not a 2ch.hk thread url")
return url
def main():
parser = argparse.ArgumentParser(prog=__prog__, description=__desc__)
parser.add_argument(
"url",
metavar="URL",
type=thread_url,
help="Thread url",
)
parser.add_argument(
"-d",
"--directory",
type=str,
default=".",
help="Download directory",
)
parser.add_argument(
"--max-directory-name-length",
metavar="LENGTH",
type=int,
default=128,
help="Max thread directory name length, 128 by default",
)
args = parser.parse_args()
download_thread_media(
args.url, Path(args.directory), args.max_directory_name_length
)
if __name__ == "__main__":
main() | 2ch-downloader | /2ch-downloader-0.0.3.tar.gz/2ch-downloader-0.0.3/_2ch_downloader.py | _2ch_downloader.py |
# 2D Utils
[](https://github.com/erlete/2dutils/actions/workflows/python-publish.yml)
A collection of 2D utilities for coordinate representation and manipulation.
## Features
The following features are currently implemented:
* `Coordinate2D` - A custom 2D coordinate representation based on the built-in `tuple` class, but with extended functionality.
* `Circumcenter` - A class for calculating the circumcenter and circumradius of three coordinates.
## Installation
### macOS/UNIX
```bash
git clone https://github.com/erlete/2d-utils
```
**Note: this package is not yet available on PyPI, but it will be really soon.**
## Usage
Once the package has been installed, its modules can be easily imported into custom programs via the `import` statement.
```python
from coordinate import Coordinate2D
from circumcenter import Circumcenter
```
| 2dutils | /2dutils-1.2.0.tar.gz/2dutils-1.2.0/README.md | README.md |
from itertools import combinations
from math import sqrt
from coordinate import Coordinate2D
class Circumcenter:
"""Class for triangle calculation.
This class is used to calculate the circumcenter of a triangle, given its
three vertices as 2D coordinates.
Args:
a (Coordinate2D): First vertex of the triangle.
b (Coordinate2D): Second vertex of the triangle.
c (Coordinate2D): Third vertex of the triangle.
Attributes:
a (Coordinate2D): First vertex of the triangle.
b (Coordinate2D): Second vertex of the triangle.
c (Coordinate2D): Third vertex of the triangle.
circumcenter (Coordinate2D): The circumcenter of the triangle.
radius (float): The radius of the circumcircle of the triangle.
"""
def __init__(self, a: Coordinate2D,
b: Coordinate2D, c: Coordinate2D) -> None:
# The initial setting variable allows value validation via attribute
# setters but prevents automatic recalculation of the circumcenter
# and circumradius.
self._initial_setting = False
self._a = a
self._b = b
self._c = c
self._initial_setting = True
self._calculate() # Initial calculation:
@property
def a(self) -> Coordinate2D:
"""First vertex of the triangle.
Returns:
Coordinate2D: First vertex of the triangle.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
return self._a
@a.setter
def a(self, value: Coordinate2D) -> None:
"""First vertex of the triangle.
Args:
value (Coordinate2D): First vertex of the triangle.
Raises:
TypeError: If the value is not a Coordinate2D object.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
if not isinstance(value, Coordinate2D):
raise TypeError("a must be a Coordinate2D instance")
self._a = value
if not self._initial_setting:
self._calculate()
@property
def b(self) -> Coordinate2D:
"""Second vertex of the triangle.
Returns:
Coordinate2D: Second vertex of the triangle.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
return self._b
@b.setter
def b(self, value: Coordinate2D) -> None:
"""Second vertex of the triangle.
Args:
value (Coordinate2D): Second vertex of the triangle.
Raises:
TypeError: If the value is not a Coordinate2D object.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
if not isinstance(value, Coordinate2D):
raise TypeError("b must be a Coordinate2D instance")
self._b = value
if not self._initial_setting:
self._calculate()
@property
def c(self) -> Coordinate2D:
"""Third vertex of the triangle.
Returns:
Coordinate2D: Third vertex of the triangle.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
return self._c
@c.setter
def c(self, value: Coordinate2D) -> None:
"""Third vertex of the triangle.
Args:
value (Coordinate2D): Third vertex of the triangle.
Raises:
TypeError: If the value is not a Coordinate2D object.
Note:
If the value of the vertex is changed, the circumcenter and radius
of the triangle are recalculated.
"""
if not isinstance(value, Coordinate2D):
raise TypeError("c must be a Coordinate2D instance")
self._c = value
if not self._initial_setting:
self._calculate()
@property
def circumcenter(self) -> Coordinate2D:
"""Circumcenter of the triangle.
Returns:
Coordinate2D: The circumcenter of the triangle.
"""
return self._circumcenter
@property
def circumradius(self) -> float:
"""Radius of the circumcircle of the triangle.
Returns:
float: The radius of the circumcircle of the triangle.
"""
return self._circumradius
def _ensure_non_collinear(self) -> None:
"""Ensures that the triangle is not collinear.
This method computes the determinant of the matrix formed by the
coordinates of the triangle's vertices. If the determinant is zero,
the triangle is collinear, and the circumcenter and circumradius
cannot be calculated.
Raises:
ValueError: If the triangle is collinear.
"""
if not (self._a.x * (self._b.y - self._c.y)
+ self._b.x * (self._c.y - self._a.y)
+ self._c.x * (self._a.y - self._b.y)):
raise ValueError("The triangle is collinear")
def _calculate(self) -> None:
"""Calculates the circumcenter and radius of the triangle."""
self._ensure_non_collinear()
if any(v[1] - v[0] for v in combinations(
(self._a, self._b, self._c), 2)):
# Vertical alignment prevention:
if not (self._b - self._a).x:
self._a, self._c = self._c, self._a
if not (self._c - self._a).x:
self._a, self._b = self._b, self._a
# Segment displacement:
displacement = {
"ab": Coordinate2D(
self.b.x - self.a.x,
self.b.y - self.a.y
),
"ac": Coordinate2D(
self.c.x - self.a.x,
self.c.y - self.a.y
)
}
# Unitary vectors:
unitary = {
"ab": Coordinate2D(
displacement["ab"].y / sqrt(
displacement["ab"].x ** 2 + displacement["ab"].y ** 2
),
-displacement["ab"].x / sqrt(
displacement["ab"].x ** 2 + displacement["ab"].y ** 2
)
),
"ac": Coordinate2D(
displacement["ac"].y / sqrt(
displacement["ac"].x ** 2 + displacement["ac"].y ** 2
),
-displacement["ac"].x / sqrt(
displacement["ac"].x ** 2 + displacement["ac"].y ** 2
)
)
}
# V-vector for vertical intersection:
vertical = {
"ab": Coordinate2D(
unitary["ab"].x / unitary["ab"].y,
1
),
"ac": Coordinate2D(
-(unitary["ac"].x / unitary["ac"].y),
1
)
}
# Midpoint setting:
midpoint = {
"ab": Coordinate2D(
displacement["ab"].x / 2 + self.a.x,
displacement["ab"].y / 2 + self.a.y
),
"ac": Coordinate2D(
displacement["ac"].x / 2 + self.a.x,
displacement["ac"].y / 2 + self.a.y
)
}
# Midpoint height equivalence:
intersection = Coordinate2D(
midpoint["ab"].x + (
(midpoint["ac"].y - midpoint["ab"].y) / unitary["ab"].y
) * unitary["ab"].x,
midpoint["ac"].y
)
# Circumcenter calculation:
self._circumcenter = Coordinate2D(
intersection.x + (
(midpoint["ac"].x - intersection.x)
/ (vertical["ab"].x + vertical["ac"].x)
) * vertical["ab"].x,
intersection.y + (
midpoint["ac"].x - intersection.x
) / (
vertical["ab"].x + vertical["ac"].x
)
)
# Circumradius calculation:
self._circumradius = sqrt(
(self.a.x - self._circumcenter.x) ** 2
+ (self.a.y - self._circumcenter.y) ** 2
) | 2dutils | /2dutils-1.2.0.tar.gz/2dutils-1.2.0/src/circumcenter.py | circumcenter.py |
from __future__ import annotations
from math import ceil, floor, trunc
from typing import Generator
class Coordinate2D:
"""Represents a pair of real-value, two dimensional coordinates.
This class represents a two-dimensional coordinate. Its main purpose is to
serve as a normalized conversion format for data going in and out of the
scripts contained in the project.
Parameters:
-----------
- x: float
The x-coordinate.
- y: float
The y-coordinate.
"""
NUMERICAL = (int, float)
SEQUENTIAL = (tuple, list, set)
def __init__(self, x_value: float, y_value: float) -> None:
self.x: float = float(x_value)
self.y: float = float(y_value)
@property
def x(self) -> float:
return self._x
@x.setter
def x(self, value) -> None:
if not isinstance(value, (int, float)):
raise TypeError("x must be an int or float")
self._x = value
@property
def y(self) -> float:
return self._y
@y.setter
def y(self, value) -> None:
if not isinstance(value, (int, float)):
raise TypeError("y must be an int or float")
self._y = value
def __add__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x + value.x, self._y + value.y)
def __sub__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x - value.x, self._y - value.y)
def __mul__(self, value) -> Coordinate2D:
if isinstance(value, Coordinate2D):
return Coordinate2D(self._x * value.x, self._y * value.y)
elif isinstance(value, self.NUMERICAL):
return Coordinate2D(self._x * value, self._y * value)
elif isinstance(value, self.SEQUENTIAL) and len(value) >= 2:
return Coordinate2D(self._x * value[0], self._y * value[1])
raise TypeError("value must be a Coordinate2D, a numerical type, or a"
"sequential type with at least 2 elements.")
def __truediv__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x / value, self._y / value)
def __floordiv__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x // value, self._y // value)
def __mod__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x % value, self._y % value)
def __pow__(self, value) -> Coordinate2D:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate2D.")
return Coordinate2D(self._x ** value, self._y ** value)
def __neg__(self) -> Coordinate2D:
return Coordinate2D(-self._x, -self._y)
def __pos__(self) -> Coordinate2D:
return Coordinate2D(+self._x, +self._y)
def __abs__(self) -> Coordinate2D:
return Coordinate2D(abs(self._x), abs(self._y))
def __invert__(self) -> Coordinate2D:
return Coordinate2D(~self._x, ~self._y)
def __round__(self, n: int = 0) -> Coordinate2D:
if not isinstance(n, int):
raise TypeError("n must be an int.")
return Coordinate2D(round(self._x, n), round(self._y, n))
def __floor__(self) -> Coordinate2D:
return Coordinate2D(floor(self._x), floor(self._y))
def __ceil__(self) -> Coordinate2D:
return Coordinate2D(ceil(self._x), ceil(self._y))
def __trunc__(self) -> Coordinate2D:
return Coordinate2D(trunc(self._x), trunc(self._y))
def __lt__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x < value.x and self._y < value.y
def __le__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x <= value.x and self._y <= value.y
def __gt__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x > value.x and self._y > value.y
def __ge__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x >= value.x and self._y >= value.y
def __eq__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x == value.x and self._y == value.y
def __ne__(self, value) -> bool:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x != value.x or self._y != value.y
def __str__(self) -> str:
return f"Coordinate2D({self._x}, {self._y})"
def __repr__(self) -> str:
return f"Coordinate2D({self._x}, {self._y})"
def __hash__(self) -> int:
return hash((self._x, self._y))
def __bool__(self) -> bool:
return self._x != 0 or self._y != 0
def __len__(self) -> int:
return 2
def __getitem__(self, index) -> float:
if index == 0:
return self._x
elif index == 1:
return self._y
else:
raise IndexError("index must be 0 or 1")
def __setitem__(self, index, value) -> None:
if index == 0:
self._x = value
elif index == 1:
self._y = value
else:
raise IndexError("index must be 0 or 1")
def __iter__(self) -> Generator[float, None, None]:
yield self._x
yield self._y
def __reversed__(self) -> Generator[float, None, None]:
yield self._y
yield self._x
def __getattr__(self, name) -> float:
if name == 'x':
return self._x
elif name == 'y':
return self._y
else:
raise AttributeError(f"{name} is not an attribute")
def __delattr__(self, name) -> None:
if name == 'x':
del self._x
elif name == 'y':
del self._y
else:
raise AttributeError(f"{name} is not an attribute")
def __getstate__(self) -> tuple[float, float]:
return self._x, self._y
def __setstate__(self, state) -> None:
self._x, self._y = state
def __reduce__(self) -> tuple[Coordinate2D, tuple[float, float]]:
return self.__class__, (self._x, self._y)
def __copy__(self) -> Coordinate2D:
return self.__class__(self._x, self._y)
def __bytes__(self) -> bytes:
return bytes(self._x) + bytes(self._y)
def __int__(self) -> int:
return int(self._x) + int(self._y)
def __float__(self) -> float:
return float(self._x) + float(self._y)
def __complex__(self) -> complex:
return complex(self._x) + complex(self._y)
def __oct__(self) -> str:
return oct(self._x) + oct(self._y)
def __hex__(self) -> str:
return hex(self._x) + hex(self._y)
def __index__(self) -> float:
return self._x + self._y
def __coerce__(self, value) -> tuple[float, float]:
if not isinstance(value, Coordinate2D):
raise TypeError("value must be a Coordinate.")
return self._x, value.x
def __format__(self, format_spec) -> str:
return format(self._x, format_spec) + format(self._y, format_spec) | 2dutils | /2dutils-1.2.0.tar.gz/2dutils-1.2.0/src/coordinate.py | coordinate.py |
# 2dwavesim
This is a project that simulates waves on 2D plates/rooms. Given boundaries (or walls) and points where oscillation will be forced, this will simulate the resulting wavemodes!
Currently it supports setting the attenuation properties of individual boundaries, multiple forcing points based on either data or a function, and any wall shape you want. It also supports variable time and space steps and spans (as long as you keep numerically stable!), as well as custom wavespeed and attenuation on the material.
TODO:
- add tests
- frequency-dependant wall transmission values
- 3D??
## Usage
There are two main Classes:
`Room(ds, width, height,*, walls=[], physics_params={})`
<ul>
This creates an instance of a `Room` class, which contains any walls or sources of the system.
`ds` is a float which defines the unit of distance between two grid points.
`width` and `height` and floats which define the dimentions of the grid. If they are not exact multiples of `ds`, then they are upper bounds on the number of points above the nearest multiple.
`walls` is a list of `Wall` objects. This can be optionally set after construction as well.
`physics_params` is a dict with structure `{'wavespeed':float, 'attenuation':float}`. Wavespeed represents the speed of the propigating wave on the room's medium, and attenuation represents the attenuation factor of waves on the medium. By defaut, wavespeed is assumed to be 343 units/s and attenuation is assumed to be $2^{-2}$ units
$^{-1}$.
**`Room.add_source_func(loc, func)`**
<ul>
Add a source based on a function.
`loc` is the room-specific coordinate of the source. Note: unless `ds=1`, this is not the same as the list indices of the point in the room.
`func` is a function taking a float (the time) and outputing a float (the value of the wave at that time). This should be something like `lambda t: np.sin(t)`, for example.
</ul>
**`Room.add_source_data(loc, data)`**
<ul>
Add a source based on a list of values. Careful! Make sure you use a `dt` value that matches the table data, as an entry of the data list will be used on every time tick. For example, if you make the data table represent the value of the wave every 200ms, then be sure to set `dt` to 200ms as well when you run the simulation. If there are less points in the list of values than there are time steps, then a value of 0 is used for all time steps past the last data point.
`loc` is the room-specific coordinate of the source. Note: unless `ds=1`, this is not the same as the list indices of the point in the room.
`data` is a list of floats (the value of the wave at that time). This should be something like `np.sin(np.arange(0, 10, 0.2))`, for example.
</ul>
**`Room.add_walls(walls)`**
<ul>
Add walls to the system after constructing the Room object.
`walls` is a list of `Wall` objects to add the the system.
</ul>
**`Room.create_mask()`**
<ul>
Create a mask for the values of the room based on the currently set walls. This is automatically done when running the simulation, but it can be run beforehand if you want to plot the mask for visualization.
</ul>
**`Room.get_mask()`**
<ul>
Returns a 2D array of the wall mask as currently calculated.
</ul>
**`Room.run(dt, t_final)`**
<ul>
Calculate the wave propagation from the set sources and using the set walls. This will simulate from `t=0` to `t_final` at `dt` time steps. If `t_final` isn't an exact multiple of `dt`, then it acts like an upper bound.
`dt` a float giving the time step for the simulation. A smaller value means more time resolution. WARNING: Numerical stability will almost certainly be lost if this is not set to satisfy the [CFL Condition](https://en.wikipedia.org/wiki/Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition), namely $\frac{u*dt}{ds} \leq C_{max}$ where $u$ is the `wavespeed` and $c_{max}$ is approximately 1 for the numerical method being used.
`t_final` a float giving an upper limit for the amount of time to be simulated. A higher value will take more time to simulate, and will likely just repeat the steady state after a certain point in time...
</ul>
</ul>
`Wall(endpoint1, endpoint2, transmission)`
<ul>
This creates an instance of a `Wall` class, which contains the wall's endpoints and transmission factor.
`endpoint1` and `endpoint2` are tuple2 or 2-list2 of floats giving the position of each end of the wall in the room-specific coordinates. Note: unless `ds=1`, this is not the same as the list indices of the point in the room.
`transmission` is a float in [0,1] which defines the proportion of wave amplitude able to penetrate the wall. If 0, then all energy is reflected back inwards, and if 1 then the wall "isn't there".
</ul>
## Visualization
The `visualization` module contains a few functions for visualizing results, or processing results into an easily displayed format.
**`animate(data, *, filepath='', frame_space=10, walls=[])`**
<ul>
Automatically animate the given data using `matplotlib.animation.ArtistAnimation`. The animation file can optionally be saved to a file.
`data` is a 3D array of waveform over time, which is the output from running the simulation.
`filename` is the name and path of output file. Leave this blank to not save. Output formats are those supported by `matplotlib.animation.ArtistAnimation`, which is at least ".gif" and ".webp".
`frame_space` is the temporal resolution of resulting animation. Make sure this isn't too small!
`walls` is to optionally include the walls in the animation. They won't be visible if this isn't included.
</ul>
**`get_steady_state_index(data, *, sample_points, rms_tolerance=0.1, window_size=0.1)`**
<ul>
This function calculates the windowed RMS of the given points over time. This data is compared to the RMS value at the end of the simulation. Then the latest time index where all point RMS's are within a tolerance to the final RMS is taken as the time index where steady-state is reached.
`data` is a 3D array of waveform over time, which is the output from running the simulation.
`sample_points` is a list of points in the room which will be checked for RMS.
`rms_tolerance` is a float in [0, 1] defining the limit on the amount the RMS is allowed to change from the final value and still be considered steady-state.
`window_size` is a float in [0, 1] defining the percent of total points to consider in the window.
</ul>
**`get_standing_waves(data, *, steady_state_kwargs=None)`**
<ul>
This function calculates when the steady state begins, and returns a 2D array which is the average of the absolute value of all of the rooms points across all steady state times.
`data` is a 3D array of waveform over time, which is the output from running the simulation.
`steady_state_kwargs` is a dict of the keyword arguments to pass to `get_steady_state_index`. If `None`, then the default parameters and a sample point at the middle of the room are used.
</ul>
| 2dwavesim | /2dwavesim-1.0.0.tar.gz/2dwavesim-1.0.0/README.md | README.md |
# 2dxPlay
Play konami 2dx files from the command line.
Install with pip and run it from anywhere.
`pip install 2dxPlay`
### Usage:
```
2dxplay infile.2dx
```
If the file contains more than one wav, it will play all tracks sequentially.
Press Ctrl+C to pause and enter a track number to jump to, or `q` to quit.
###Tip: Play any 2dx file just by double clicking on it:
Right click on a 2dx file, choose Open With > Look for another app on this PC.
Navigate to your python installation where 2dxPlay.exe is installed. (I use python 3.7, so pip
installed it in `%appdata%\Local\Programs\Python\Python37\Scripts`).
Check the "Always use this app" box and profit.
 | 2dxPlay | /2dxPlay-1.0.1.tar.gz/2dxPlay-1.0.1/README.md | README.md |
import os
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
from os import path
from pygame import mixer
from twodxPlay.twodx import Twodx
import sys, traceback
from datetime import timedelta
import struct
import argparse
version='V1.0.1'
parser = argparse.ArgumentParser(description='A command line app for playing and extracting konami 2dx audio files.')
parser.add_argument('infile')
parser.add_argument('-e', '--extract', nargs='?', const='all', help='Extract the wav files. Optionally specify a number, a comma-separated list of numbers or a range such as 10-20.'
' Don\'t use spaces, and NOTE that extracted wav files will start at 0.wav. Example: 2dxplay -e 1,4-8,10 infile.2dx')
parser.add_argument('-o', '--output-dir', default='output', help='Directory to extract files to. Will be created if not exists. Default is ./output/')
if len(sys.argv) <= 1:
print(f"2dxPlay {version}")
parser.print_help()
sys.exit(1)
args = parser.parse_args()
mixer.init()
infile = args.infile
outdir = args.output_dir
try:
twodx_file = Twodx(path.abspath(infile))
except struct.error:
traceback.print_exc()
print("Probably not a 2dx file.")
sys.exit(1)
except:
traceback.print_exc()
sys.exit(1)
current_track = 1
# function from bemaniutils/afputils.
def parse_intlist(data):
ints = []
for chunk in data.split(","):
chunk = chunk.strip()
if '-' in chunk:
start, end = chunk.split('-', 1)
start_int = int(start.strip())
end_int = int(end.strip())
ints.extend(range(start_int, end_int + 1))
else:
ints.append(int(chunk))
return sorted(set(ints))
def extract(data=None):
if outdir != '.' and not os.path.exists(outdir):
os.mkdir(outdir)
if args.extract == 'all':
for i in range(twodx_file.file_count):
wav = twodx_file.load(i)
print(f"Writing {i+1}/{twodx_file.file_count} wavs to {outdir}")
with open(f"{outdir}/{i}.wav", 'wb') as f:
f.write(wav.getbuffer())
else:
if data:
ints = parse_intlist(data)
else:
ints = parse_intlist(args.extract)
for i in ints:
wav = twodx_file.load(i-1)
print(f"Writing {i-1}.wav to {outdir}")
with open(f"{args.output_dir}/{i-1}.wav", 'wb') as f:
f.write(wav.getbuffer())
def main():
if args.extract:
extract()
sys.exit()
global current_track
try:
while current_track-1 < twodx_file.file_count:
wav = twodx_file.load(current_track-1)
sound = mixer.Sound(wav)
channel = sound.play()
length = timedelta(seconds=int(sound.get_length()))
print(f"Playing: {infile} Track {current_track}/{twodx_file.file_count} Length: {length}")
while channel.get_busy():
pass
current_track += 1
except KeyboardInterrupt:
mixer.stop()
while "the answer is invalid":
try:
reply = str(input('Enter track number to jump to, e [track(s) to extract], or q to quit: ')).lower().strip()
except (EOFError, KeyboardInterrupt):
sys.exit(0)
if reply == 'q':
sys.exit(0)
if reply[0] == 'e':
ints = reply.split()
if len(reply) > 1:
extract(reply.split()[1])
else:
continue
if reply.isdigit() and int(reply) in range(1, twodx_file.file_count + 1):
current_track = int(reply)
main()
except Exception:
traceback.print_exc()
sys.exit(1)
if __name__ == "__main__":
main() | 2dxPlay | /2dxPlay-1.0.1.tar.gz/2dxPlay-1.0.1/twodxPlay/main.py | main.py |
import base64
import hashlib
import hmac
class OTP(object):
def __init__(self, s, digits=6, digest=hashlib.sha1):
"""
@param [String] secret in the form of base32
@option options digits [Integer] (6)
Number of integers in the OTP
Google Authenticate only supports 6 currently
@option options digest [Callable] (hashlib.sha1)
Digest used in the HMAC
Google Authenticate only supports 'sha1' currently
@returns [OTP] OTP instantiation
"""
self.digits = digits
self.digest = digest
self.secret = s
def generate_otp(self, input):
"""
@param [Integer] input the number used seed the HMAC
Usually either the counter, or the computed integer
based on the Unix timestamp
"""
hmac_hash = hmac.new(
self.byte_secret(),
self.int_to_bytestring(input),
self.digest,
).digest()
hmac_hash = bytearray(hmac_hash)
offset = hmac_hash[-1] & 0xf
code = ((hmac_hash[offset] & 0x7f) << 24 |
(hmac_hash[offset + 1] & 0xff) << 16 |
(hmac_hash[offset + 2] & 0xff) << 8 |
(hmac_hash[offset + 3] & 0xff))
str_code = str(code % 10 ** self.digits)
while len(str_code) < self.digits:
str_code = '0' + str_code
return str_code
def byte_secret(self):
missing_padding = len(self.secret) % 8
if missing_padding != 0:
self.secret += '=' * (8 - missing_padding)
return base64.b32decode(self.secret, casefold=True)
@staticmethod
def int_to_bytestring(i, padding=8):
"""
Turns an integer to the OATH specified
bytestring, which is fed to the HMAC
along with the secret
"""
result = bytearray()
while i != 0:
result.append(i & 0xFF)
i >>= 8
# It's necessary to convert the final result from bytearray to bytes because
# the hmac functions in python 2.6 and 3.3 don't work with bytearray
return bytes(bytearray(reversed(result)).rjust(padding, b'\0')) | 2fa | /2fa-0.0.1.tar.gz/2fa-0.0.1/pyotp/otp.py | otp.py |
import datetime
import time
from pyotp import utils
from pyotp.otp import OTP
class TOTP(OTP):
def __init__(self, *args, **kwargs):
"""
@option options [Integer] interval (30) the time interval in seconds
for OTP This defaults to 30 which is standard.
"""
self.interval = kwargs.pop('interval', 30)
super(TOTP, self).__init__(*args, **kwargs)
def at(self, for_time, counter_offset=0):
"""
Accepts either a Unix timestamp integer or a Time object.
Time objects will be adjusted to UTC automatically
@param [Time/Integer] time the time to generate an OTP for
@param [Integer] counter_offset an amount of ticks to add to the time counter
"""
if not isinstance(for_time, datetime.datetime):
for_time = datetime.datetime.fromtimestamp(int(for_time))
return self.generate_otp(self.timecode(for_time) + counter_offset)
def now(self):
"""
Generate the current time OTP
@return [Integer] the OTP as an integer
"""
return self.generate_otp(self.timecode(datetime.datetime.now()))
def verify(self, otp, for_time=None, valid_window=0):
"""
Verifies the OTP passed in against the current time OTP
@param [String/Integer] otp the OTP to check against
@param [Integer] valid_window extends the validity to this many counter ticks before and after the current one
"""
if for_time is None:
for_time = datetime.datetime.now()
if valid_window:
for i in range(-valid_window, valid_window + 1):
if utils.strings_equal(str(otp), str(self.at(for_time, i))):
return True
return False
return utils.strings_equal(str(otp), str(self.at(for_time)))
def provisioning_uri(self, name, issuer_name=None):
"""
Returns the provisioning URI for the OTP
This can then be encoded in a QR Code and used
to provision the Google Authenticator app
@param [String] name of the account
@return [String] provisioning uri
"""
return utils.build_uri(self.secret, name, issuer_name=issuer_name)
def timecode(self, for_time):
i = time.mktime(for_time.timetuple())
return int(i / self.interval) | 2fa | /2fa-0.0.1.tar.gz/2fa-0.0.1/pyotp/totp.py | totp.py |
from __future__ import print_function, unicode_literals, division, absolute_import
import unicodedata
try:
from urllib.parse import quote
except ImportError:
from urllib import quote
def build_uri(secret, name, initial_count=None, issuer_name=None):
"""
Returns the provisioning URI for the OTP; works for either TOTP or HOTP.
This can then be encoded in a QR Code and used to provision the Google
Authenticator app.
For module-internal use.
See also:
http://code.google.com/p/google-authenticator/wiki/KeyUriFormat
@param [String] the hotp/totp secret used to generate the URI
@param [String] name of the account
@param [Integer] initial_count starting counter value, defaults to None.
If none, the OTP type will be assumed as TOTP.
@param [String] the name of the OTP issuer; this will be the
organization title of the OTP entry in Authenticator
@return [String] provisioning uri
"""
# initial_count may be 0 as a valid param
is_initial_count_present = (initial_count is not None)
otp_type = 'hotp' if is_initial_count_present else 'totp'
base = 'otpauth://%s/' % otp_type
if issuer_name:
issuer_name = quote(issuer_name)
base += '%s:' % issuer_name
uri = '%(base)s%(name)s?secret=%(secret)s' % {
'name': quote(name, safe='@'),
'secret': secret,
'base': base,
}
if is_initial_count_present:
uri += '&counter=%s' % initial_count
if issuer_name:
uri += '&issuer=%s' % issuer_name
return uri
def strings_equal(s1, s2):
"""
Timing-attack resistant string comparison.
Normal comparison using == will short-circuit on the first mismatching
character. This avoids that by scanning the whole string, though we
still reveal to a timing attack whether the strings are the same
length.
"""
s1 = unicodedata.normalize('NFKC', s1)
s2 = unicodedata.normalize('NFKC', s2)
try:
# Python 3.3+ and 2.7.7+ include a timing-attack-resistant
# comparison function, which is probably more reliable than ours.
# Use it if available.
from hmac import compare_digest
return compare_digest(s1, s2)
except ImportError:
pass
if len(s1) != len(s2):
return False
differences = 0
for c1, c2 in zip(s1, s2):
differences |= ord(c1) ^ ord(c2)
return differences == 0 | 2fa | /2fa-0.0.1.tar.gz/2fa-0.0.1/pyotp/utils.py | utils.py |
import time
import threading
import urwid
import argparse
import random
from feeds.display import FeedsTreeBrowser
from feeds.utils import *
from feeds.input_mod import *
f = None
def insert_feeds(feeds):
global q, f
try:
all_src = []
while True:
s = q.get(timeout=7)
content = s.preview()
all_src.append(s)
# added new check for None
if content is None:
continue
f.init_data(content)
q.queue.clear()
except Exception as e:
pass
finally:
f.done = True
def _start():
global q, f, progress
# cli
parser = argparse.ArgumentParser(prog='2feeds')
group = parser.add_mutually_exclusive_group()
group.add_argument('-a', '--add',
action='store_true', help='add a new feed')
group.add_argument('-l', '--list', action='store_true',
help='list saved feeds')
group.add_argument('-r', '--remove', action='store_true',
help='remove a feed from your collection')
group.add_argument('-c', '--clear', action='store_true',
help='clear feed collection and/or clear viewing cache')
args = parser.parse_args()
cli = False
if args.add or args.list or args.remove or args.clear:
cli = True
if args.add:
addLink()
elif args.list:
listSavedSites()
elif args.remove:
delete_feed()
elif args.clear:
clear_data()
if cli:
exit()
feeds = getParam('url')
random.shuffle(feeds)
feeds = tuple(feeds)
if len(feeds) == 0:
print('add some feeds using -a option.')
exit(-1)
# get feeds
progress = set(getProgress())
request_feeds = threading.Thread(
target=get_feeds_from_url, args=(feeds, progress,))
request_feeds.start()
# init display
f = FeedsTreeBrowser()
# grab feeds from queue
add_feed = threading.Thread(target=insert_feeds, args=(feeds,))
add_feed.start()
# run event loop
links = f.main()
if links != []:
saveProgress(links)
request_feeds.join()
add_feed.join()
if __name__ == "__main__":
_start() | 2feeds | /2feeds-1.0.210-py3-none-any.whl/feeds/main.py | main.py |
import os
import re
import json
import time
DIR_BASE = os.path.dirname(os.path.abspath(__file__))
dir_path = DIR_BASE + "/.app_data"
udata_path = dir_path + "/udata.dat"
ucache_path = dir_path + "/ucache.dat"
regex = re.compile(
r'^(?:http|ftp)s?://'
)
def checkFiles():
if not os.path.isdir(dir_path):
os.makedirs(dir_path)
if not os.path.exists(udata_path):
with open(udata_path, 'w') as f:
f.write('[]')
if not os.path.exists(ucache_path):
with open(ucache_path, 'w') as f:
f.write('[]')
def addLink():
checkFiles()
links = getOldLinks()
link_set = set([x['url'] for x in links])
link = input('Paste RSS link here: ')
if re.match(regex, link) is None:
print("Not a valid url")
exit()
title = input('Site-name: ')
data = {
'url': link,
'title': title,
'time': time.time()
}
if data['url'] in link_set:
print('Already added, exiting')
exit()
links.append(data)
with open(udata_path, 'w') as f:
json.dump(links, f)
def getOldLinks():
with open(udata_path, 'r') as f:
content = f.read()
data = json.loads(content)
return data
def listSavedSites():
sites = getParam('title')
if len(sites) == 0:
print('Empty collection. Please update')
exit()
for x in sites:
print(' x ' + x)
def getParam(param):
checkFiles()
links_dict = getOldLinks()
result = []
for x in links_dict:
result.append(x[param])
return result
def updateParam(param, item):
checkFiles()
links_dict = getOldLinks()
if len(links_dict) == 0:
print('Nothing to update')
exit()
valid = []
for x in links_dict:
if item != x[param]:
valid.append(x)
with open(udata_path, 'w') as f:
json.dump(valid, f)
def delete_feed():
listSavedSites()
item = input('Enter site-name: ')
updateParam('title', item)
def getProgress():
checkFiles()
with open(ucache_path, 'r') as f:
content = f.read()
data = json.loads(content)
return data
def saveProgress(url):
checkFiles()
links = getProgress()
links.extend(url)
with open(ucache_path, 'w') as f:
json.dump(list(set(links)), f)
def clear_data():
choice = input('would you like to clear viewing cache? (y/n): ')
if choice in ('y', "Y", "yes", "Yes"):
with open(ucache_path, 'w') as f:
f.write('[]')
choice = input('would you like to clear feed sources? (y/n): ')
if choice in ('y', "Y", "yes", "Yes"):
with open(udata_path, 'w') as f:
f.write('[]') | 2feeds | /2feeds-1.0.210-py3-none-any.whl/feeds/input_mod.py | input_mod.py |
import queue
import threading
import feedparser
from html.parser import HTMLParser
q = queue.Queue()
class MLStripper(HTMLParser):
def __init__(self):
self.reset()
self.strict = False
self.convert_charrefs = True
self.fed = []
def handle_data(self, d):
self.fed.append(d)
def get_data(self):
return ''.join(self.fed)
def strip_tags(html):
s = MLStripper()
s.feed(html)
return s.get_data().strip()
class RSS_parser:
def __init__(self, url, progress):
self.url = url
self.stories = []
self.init(progress)
self.pos = 0
def __len__(self):
return len(self.stories)
def init(self, progress):
p = feedparser.parse(self.url)
exception = p.get('bozo_exception', None)
if exception is not None:
exit(-1) # exit if no internet connection; no attempt to reconnect
for i in range(len(p.entries)):
url = p.entries[i].link
if url not in progress:
self.stories.append(
{"name": strip_tags(p.entries[i].title), "url": url, "children": [{"name": strip_tags(p.entries[i].description)}]})
def preview(self):
# added return
if self.pos > len(self.stories):
return None
count = 0
end = len(self.stories) if self.pos + \
3 > len(self.stories) else self.pos + 3
for i in range(self.pos, end):
count += 1
result = self.stories[self.pos:end]
self.pos += count
return result
# add dependency ?
def get_feeds_from_url(urls, progress):
for url in urls:
try:
r = RSS_parser(url, progress)
if len(r) == 0:
continue
q.put(r)
except Exception as e:
pass # is it okay to pass ?
def check_if_empty(all_feeds):
if len(list(filter(lambda x: x.pos >= len(x.stories), all_feeds))) == len(
all_feeds
):
return True
return False | 2feeds | /2feeds-1.0.210-py3-none-any.whl/feeds/utils.py | utils.py |
import urwid
import time
import threading
import webbrowser
state = {
'expanded': {},
'isFlagged': {}
}
class FeedTreeWidget(urwid.TreeWidget):
""" Display widget for leaf nodes """
unexpanded_icon = urwid.AttrMap(urwid.TreeWidget.unexpanded_icon,
'dirmark')
expanded_icon = urwid.AttrMap(urwid.TreeWidget.expanded_icon,
'dirmark')
indent_cols = 4
def __init__(self, node, is_expanded=None, is_flagged=None):
self.__super.__init__(node)
if self.get_node()._parent is not None:
self.keypress(None, "-")
if is_expanded is not None:
if is_expanded:
self.keypress(None, "+")
else:
self.keypress(None, "-")
self._w = urwid.AttrWrap(self._w, None)
if is_flagged is not None:
self.flagged = is_flagged
else:
self.flagged = False
self.update_w()
def update_w(self):
"""Update the attributes of self.widget based on self.flagged.
"""
if self.flagged:
self._w.attr = 'flagged focus' # 'flagged'
self._w.focus_attr = 'flagged focus'
else:
self._w.attr = 'body'
self._w.focus_attr = 'focus'
def get_display_text(self):
return self.get_node().get_value()['name']
def get_feed_url(self):
return self.get_node().get_value()['url']
def selectable(self):
"""
Allow selection of non-leaf nodes so children may be (un)expanded
"""
return not self.is_leaf and self.get_node()._parent is not None
def mouse_event(self, size, event, button, col, row, focus):
if self.is_leaf or event != 'mouse press' or button != 1 or self.get_node()._parent is None:
return False
if row == 0 and col == self.get_indent_cols():
self.expanded = not self.expanded
self.update_expanded_icon()
return True
return False
def unhandled_keys(self, size, key):
"""
Override this method to intercept keystrokes in subclasses.
Default behavior: Toggle flagged on space, ignore other keys.
"""
if key in (" ", "enter"):
if key == "enter":
self.flagged = True
else:
self.flagged = not self.flagged
self.update_w()
return key
def keypress(self, size, key):
"""Handle expand & collapse requests (non-leaf nodes)"""
if self.is_leaf:
return key
if key in ("+", "right"):
self.expanded = True
self.update_expanded_icon()
elif key in ("-", "left"):
self.expanded = False
self.update_expanded_icon()
elif key in (" ", "enter"):
return self.unhandled_keys(size, key)
elif self._w.selectable():
return self.__super.keypress(size, key)
else:
return key
def load_inner_widget(self):
if self.is_leaf:
return urwid.AttrMap(urwid.Text(self.get_display_text()), 'summary')
else:
return urwid.Text(self.get_display_text())
def get_indented_widget(self):
widget = self.get_inner_widget()
div = urwid.Divider()
if not self.is_leaf:
widget = urwid.Columns([('fixed', 1,
[self.unexpanded_icon, self.expanded_icon][self.expanded]),
widget], dividechars=1)
else:
widget = urwid.Pile([widget, div])
indent_cols = self.get_indent_cols()
return urwid.Padding(widget,
width=('relative', 100), left=indent_cols, right=indent_cols)
class Node(urwid.TreeNode):
""" Data storage object for leaf nodes """
def load_widget(self):
return FeedTreeWidget(self)
class FeedParentNode(urwid.ParentNode):
""" Data storage object for interior/parent nodes """
def __init__(self, value, parent=None, key=None, depth=None):
urwid.TreeNode.__init__(
self, value, parent=parent, key=key, depth=depth)
self._child_keys = None
self._children = {}
self.is_expanded = None
self.is_flagged = None
def load_widget(self):
return FeedTreeWidget(self, self.is_expanded, self.is_flagged)
def load_child_keys(self):
data = self.get_value()
return range(len(data['children']))
def load_child_node(self, key):
"""Return either an Node or ParentNode"""
childdata = self.get_value()['children'][key]
childdepth = self.get_depth() + 1
if 'children' in childdata:
childclass = FeedParentNode
else:
childclass = Node
return childclass(childdata, parent=self, key=key, depth=childdepth)
def append_child_node(self, data):
self._value["children"].extend(data["children"])
saved_links = []
class CustomTree(urwid.TreeListBox):
def unhandled_input(self, size, input):
"""Handle macro-navigation keys"""
if input == 'left':
return input
elif input == '-':
self.collapse_focus_parent(size)
elif input == "enter":
widget, pos = self.body.get_focus()
url = widget.get_feed_url()
webbrowser.open(url)
self.add_link(url)
elif input == " ":
widget, pos = self.body.get_focus()
url = widget.get_feed_url()
self.add_or_remove_link(url)
else:
return input
def add_link(self, url):
if url not in saved_links:
saved_links.append(url)
def add_or_remove_link(self, url):
if url not in saved_links:
saved_links.append(url)
else:
saved_links.pop(saved_links.index(url))
class FeedsTreeBrowser:
palette = [
('body', 'white', 'black'),
('dirmark', 'light red', 'black', 'bold'),
# ('title', 'default,bold', 'default', 'bold'),
('key', 'light cyan', 'black'),
('focus', 'light gray', 'dark blue', 'standout'),
('title', 'default,bold', 'default', 'bold'),
('summary', 'black', 'light gray'),
# ('flagged', 'black', 'dark green', ('bold', 'underline')),
('flagged', 'black', 'light green'),
('flagged focus', 'black', 'dark cyan',
('bold', 'standout', 'underline')),
# ('foot', 'light gray', 'black'),
# ('flag', 'dark gray', 'light gray'),
# ('error', 'dark red', 'light gray'),
]
footer_text = [
('title', ""), "",
('key', "UP"), ",", ('key', "DOWN"), ",",
# ('key', "PAGE UP"), ",", ('key', "PAGE DOWN"),
" ",
('key', "+"), ",",
('key', "-"), ",",
('key', "RIGHT"), ",",
('key', "LEFT"), " ",
('key', "ENTER"), ",",
('key', "SPACE"), " ",
('key', "Q"),
]
def __init__(self, data=None):
self.header = urwid.Text("2Feeds", align="left")
self.footer = urwid.AttrMap(urwid.Text(self.footer_text),
'foot')
self.start = True
self.done = False
def init_data(self, data):
if self.start:
self.topnode = FeedParentNode(None)
d_ = {"name": "/", "children": []}
d_["children"].extend(data)
self.topnode._value = d_
self.tw = urwid.TreeWalker(self.topnode)
self.listbox = CustomTree(self.tw)
self.start = False
else:
d_ = self.topnode._value
d_["children"].extend(data)
self.topnode = FeedParentNode(d_)
def generate_frame(self):
return urwid.Padding(urwid.Frame(
urwid.AttrMap(self.listbox, 'body'),
header=urwid.AttrMap(self.header, 'title'),
footer=self.footer), left=1, right=2)
def store_state(self):
node = self.loop.widget.base_widget.body.base_widget._body.focus
parent = node.get_parent()
keys = parent.get_child_keys()
for key in keys:
state['expanded'][key] = parent.get_child_widget(key).expanded
state['isFlagged'][key] = parent.get_child_widget(key).flagged
def restore_state(self):
keys = self.topnode.get_child_keys()
prev_len = len(state['expanded'])
for i, key in enumerate(keys):
_ = self.topnode.get_child_node(key)
if i < prev_len:
self.topnode._children[key].is_expanded = state['expanded'][key]
self.topnode._children[key].is_flagged = state['isFlagged'][key]
def refresh(self, _loop, _data):
"""
Redraw screen;
TODO: is there a better way?
"""
global stop_adding
node = self.tw.get_focus()[1]
key = node.get_key()
self.store_state()
self.restore_state()
self.tw = urwid.TreeWalker(self.topnode.get_child_node(key))
# self.loop.widget.base_widget.body.base_widget._body = self.tw
self.listbox = CustomTree(self.tw)
self.loop.widget.base_widget.body = self.listbox
if not self.done:
self.loop.set_alarm_in(1, self.refresh)
def main(self):
"""Run the program."""
try:
count = 0
while not hasattr(self, 'listbox'):
time.sleep(1)
count += 1
if count == 15:
# print('time exceeded')
raise Exception('time exceeded')
continue
self.frame = urwid.AttrMap(self.generate_frame(), 'body')
self.loop = urwid.MainLoop(self.frame, self.palette,
unhandled_input=self.unhandled_input)
self.loop.set_alarm_in(1, self.refresh)
self.loop.run()
except Exception as e:
err_msg = """error occured:\n- check internet connection\n- add more sources"""
print(err_msg)
exit(-1)
finally:
return saved_links
def unhandled_input(self, k):
if k in ('q', 'Q'):
raise urwid.ExitMainLoop() | 2feeds | /2feeds-1.0.210-py3-none-any.whl/feeds/display.py | display.py |
import inspect
try:
import urlparse
except ImportError: # Python 3
from urllib import parse as urlparse
try:
from urllib import urlencode
except ImportError: # Python 3
from urllib.parse import urlencode
import requests
from dgis.exceptions import DgisError
from dgis.utils import force_text
__all__ = ('bind_api',)
def __init__(self, api):
self.api = api
def execute(self, *args, **kwargs):
# Build GET parameters for query
parameters = {}
# Both positional
for idx, arg in enumerate(args):
if arg is None:
continue
try:
parameters[self.allowed_param[idx]] = force_text(arg)
except IndexError:
raise ValueError('Too many parameters supplied')
# And keyword parameters
for key, arg in kwargs.items():
if arg is None:
continue
if key in parameters:
raise ValueError('Multiple values for parameter %s supplied' % key)
parameters[key] = force_text(arg)
parameters.update({
'key': self.api.key,
'version': self.api.version,
'output': 'json',
})
url = urlparse.urlunparse(['http', self.api.host, self.path, None, urlencode(parameters), None])
response = requests.get(url).json
if inspect.ismethod(response):
response = response()
if response['response_code'] != '200':
raise DgisError(int(response['response_code']), response['error_message'], response['error_code'])
# Register view if required
if self.register_views and self.api.register_views:
if requests.get(response['register_bc_url']).text == '0':
raise DgisError(404, 'View registration cannot be processed', 'registerViewFailed')
return response
def bind_api(**config):
properties = {
'path': config['path'],
'method': config.get('method', 'GET'),
'allowed_param': config['allowed_param'],
'register_views': config.get('register_views', False),
'__init__': __init__,
'execute': execute,
}
cls = type('API%sMethod' % config['path'].title().replace('/', ''), (object,), properties)
def _call(api, *args, **kwargs):
return cls(api).execute(*args, **kwargs)
return _call | 2gis | /2gis-1.3.1.tar.gz/2gis-1.3.1/dgis/binder.py | binder.py |
from dgis.binder import bind_api
__version__ = '1.3.1'
class API(object):
"""2GIS API"""
def __init__(self, key, host='catalog.api.2gis.ru', version='1.3', register_views=True):
"""
Parameters::
key : user API key
host : base URL for queries
version : API version for working
register_views : send information to stats server about a firm profile viewing
"""
self.key = key
self.host = host
self.version = version
self.register_views = register_views
"""Projects lists
http://api.2gis.ru/doc/firms/list/project-list/
"""
project_list = bind_api(
path='/project/list',
allowed_param=[],
)
"""List of the project cities
http://api.2gis.ru/doc/firms/list/city-list/
"""
city_list = bind_api(
path='/city/list',
allowed_param=['where', 'project_id']
)
def rubricator(self, **kwargs):
"""Rubrics search
http://api.2gis.ru/doc/firms/list/rubricator/
"""
# `show_children' parameter must be an integer
kwargs['show_children'] = int(kwargs.pop('show_children', False))
return self._rubricator(**kwargs)
_rubricator = bind_api(
path='/rubricator',
allowed_param=['where', 'id', 'parent_id', 'show_children', 'sort'],
)
def search(self, **kwargs):
"""Firms search
http://api.2gis.ru/doc/firms/searches/search/
"""
point = kwargs.pop('point', False)
if point:
kwargs['point'] = '%s,%s' % (point[0], point[1])
bound = kwargs.pop('bound', False)
if bound:
kwargs['bound[point1]'] = bound[0]
kwargs['bound[point2]'] = bound[1]
filters = kwargs.pop('filters', False)
if filters:
for k, v in filters.items():
kwargs['filters[%s]' % k] = v
return self._search(**kwargs)
_search = bind_api(
path='/search',
allowed_param=['what', 'where', 'point', 'radius', 'bound', 'page', 'pagesize', 'sort', 'filters'],
)
def search_in_rubric(self, **kwargs):
"""Firms search in rubric
http://api.2gis.ru/doc/firms/searches/searchinrubric/
"""
point = kwargs.pop('point', False)
if point:
kwargs['point'] = '%s,%s' % point
bound = kwargs.pop('bound', False)
if bound:
kwargs['bound[point1]'] = bound[0]
kwargs['bound[point2]'] = bound[1]
filters = kwargs.pop('filters', False)
if filters:
for k, v in filters.items():
kwargs['filters[%s]' % k] = v
return self._search_in_rubric(**kwargs)
_search_in_rubric = bind_api(
path='/searchinrubric',
allowed_param=['what', 'where', 'point', 'radius', 'bound', 'page', 'pagesize', 'sort', 'filters'],
)
"""Firm filials
http://api.2gis.ru/doc/firms/searches/firmsbyfilialid/
"""
firms_by_filial_id = bind_api(
path='/firmsByFilialId',
allowed_param=['firmid', 'page' 'pagesize'],
)
"""Adverts search
http://api.2gis.ru/doc/firms/searches/adssearch/
"""
ads_search = bind_api(
path='/ads/search',
allowed_param=['what', 'where', 'format', 'page', 'pagesize'],
)
"""Firm profile
http://api.2gis.ru/doc/firms/profiles/profile/
"""
profile = bind_api(
path='/profile',
allowed_param=['id', 'hash'],
register_views=True,
)
def geo_search(self, **kwargs):
"""Geo search
http://api.2gis.ru/doc/geo/search/
"""
if 'types' in kwargs:
kwargs['types'] = ','.join(kwargs['types'])
bound = kwargs.pop('bound', False)
if bound:
kwargs['bound[point1]'] = bound[0]
kwargs['bound[point2]'] = bound[1]
return self._geo_search(**kwargs)
_geo_search = bind_api(
path='/geo/search',
allowed_param=['q', 'types', 'radius', 'limit', 'project', 'bound', 'format'],
)
"""Information about a geo object"""
geo_get = bind_api(
path='/geo/search',
allowed_param=['id', ],
) | 2gis | /2gis-1.3.1.tar.gz/2gis-1.3.1/dgis/__init__.py | __init__.py |
# Python 2ip Module
**2ip** allows you to make requests to the 2ip.me API to retrieve provider/geographic information for IP addresses. Requests are (optionally, on by default) cached to prevent unnecessary API lookups when possible.
## Installation
Install the module from PyPI:
```bash
python3 -m pip install 2ip
```
## Methods
The following methods are available.
### TwoIP (Initialisation)
When initialising the 2ip module the following parameters may be specified:
* *Optional* `key`: The API key to use for lookups. If no API key defined the API lookups will use the rate limited free API.
### geo
The geographic lookup method accepts the following parameters:
* *Required* `ip`: The IP address to lookup.
* *Optional* `format` {**json**,xml}: The output format for the request. `json` will return a dict and `xml` will return a string.
* *Optional* `force` {True,**False**}: Force an API lookup even if there is a cache entry.
* *Optional* `cache` {**True**,False}: Allow the lookup result to be cached.
### provider
The provider lookup method accepts the following parameters:
* *Required* `ip`: The IP address to lookup.
* *Optional* `format` {**json**,xml}: The output format for the request. `json` will return a dict and `xml` will return a string.
* *Optional* `force` {True,**False**}: Force an API lookup even if there is a cache entry.
* *Optional* `cache` {**True**,False}: Allow the lookup result to be cached.
## Examples
Some example scripts are included in the [examples](examples/) directory.
### Provider API
Retrieve provider information for the IP address `192.0.2.0` as a `dict`:
```python
>>> from twoip import TwoIP
>>> twoip = TwoIP(key = None)
>>> twoip.provider(ip = '192.0.2.0')
{'ip': '192.0.2.0',
'ip_range_end': '3221226239',
'ip_range_start': '3221225984',
'mask': '24',
'name_ripe': 'Reserved AS',
'name_rus': '',
'route': '192.0.2.0'}
```
Retrieve provider information for the IP address `192.0.2.0` as a XML string:
```python
>>> from twoip import TwoIP
>>> twoip = TwoIP(key = None)
>>> twoip.provider(ip = '192.0.2.0', format = 'xml')
'<?xml version="1.0" encoding="UTF-8"?>\n<provider_api><ip>192.0.2.0</ip><name_ripe>Reserved AS</name_ripe><name_rus></name_rus><ip_range_start>3221225984</ip_range_start><ip_range_end>3221226239</ip_range_end><route>192.0.2.0</route><mask>24</mask></provider_api>'
```
### Geographic API
Retrieve geographic information for the IP address `8.8.8.8` as a `dict`:
```python
>>> from twoip import TwoIP
>>> twoip = TwoIP(key = None)
>>> twoip.geo(ip = '8.8.8.8')
{'city': 'Mountain view',
'country': 'United states of america',
'country_code': 'US',
'country_rus': 'США',
'country_ua': 'США',
'ip': '8.8.8.8',
'latitude': '37.405992',
'longitude': '-122.078515',
'region': 'California',
'region_rus': 'Калифорния',
'region_ua': 'Каліфорнія',
'time_zone': '-08:00',
'zip_code': '94043'}
```
Retrieve geographic information for the IP address `8.8.8.8` as a XML string:
```python
>>> from twoip import TwoIP
>>> twoip = TwoIP(key = None)
>>> twoip.geo(ip = '8.8.8.8', format = 'xml')
'<?xml version="1.0" encoding="UTF-8"?>\n<geo_api><ip>8.8.8.8</ip><country_code>US</country_code><country>United states of america</country><country_rus>США</country_rus><country_ua>США</country_ua><region>California</region><region_rus>Калифорния</region_rus><region_ua>Каліфорнія</region_ua><city>Mountain view</city><latitude>37.405992</latitude><longitude>-122.078515</longitude><zip_code>94043</zip_code><time_zone>-08:00</time_zone></geo_api>'
```
## Roadmap/Todo
- [ ] Support for email API
- [ ] Support for MAC address API
- [ ] Support for hosting API
- [x] Option to retrieve data as XML
- [ ] Unit tests
- [x] Deduplicate handler to retrieve information from API
| 2ip | /2ip-0.0.2.tar.gz/2ip-0.0.2/README.md | README.md |
import logging
import requests
from ipaddress import ip_address
from typing import Optional, Union
class TwoIP(object):
"""
2ip.me API client
"""
# The API URL
api = 'https://api.2ip.me'
# List of available API endpoints
endpoints = {
'ip': {
'geo': {
'format': [ 'json', 'xml' ],
'description': 'Geographic information for IP addresses',
},
'provider': {
'format': [ 'json', 'xml' ],
'description': 'Provider information for IP addresses',
},
},
}
def __init__(self, key: Optional[str] = None) -> object:
"""Set up new 2ip.me API client.
Parameters
----------
key : str, optional
Optional API key to use for requests to the API
Returns
-------
TwoIP : object
The TwoIP API object
Examples
--------
>>> twoip = TwoIP(key = None)
"""
# Set API key
self.__key = key
# Create empty cache
self.__cache = {}
for endpoint_type in self.endpoints:
for type in self.endpoints[endpoint_type]:
self.__cache[type] = {}
for format in self.endpoints[endpoint_type][type]['format']:
self.__cache[type][format] = {}
# Debugging
if key:
logging.debug(f'Setup of new TwoIP object')
else:
logging.debug(f'Setup of new TwoIP object (No API key used - rate limits will apply)')
@staticmethod
def __api_request(url: str, params: Optional[dict] = None) -> object:
"""Send request to the 2ip API and return the requests object.
Parameters
----------
url : str
The URL to send request to
params : dict, Optional
Optional GET parameters to add to the request
Returns
-------
object
The requests object
Raises
------
RuntimeError
If the API request fails
"""
# Send the request
try:
req = requests.request(method = 'GET', url = url, params = params)
except Exception as e:
raise RuntimeError('API request failed') from e
# Make sure API request didn't result in rate limit
if req.status_code == 429:
raise RuntimeError(f'API has reached rate limit; retry in an hour or use an API key')
# Make sure response code is fine
if req.status_code != 200:
raise RuntimeError(f'Received unexpected response code "{req.status_code}" from API')
# Return the requests object
return req
def __api_param(self, params: dict) -> dict:
"""Add API key to the list of parameters for the API request if available.
Parameters
----------
params : dict
The parameters to add API key to
Returns
-------
dict
The built parameter list
"""
# Add API key if available
if self.__key:
params['key'] = self.__key
# Return params
return params
@staticmethod
def __test_ip(ip: str) -> bool:
"""Test if the IP address provided is really an IP address.
Parameters
----------
params : ip
The IP address to test
Returns
-------
bool
True if the string provided is an IP address or False if it is not an IP address
"""
logging.debug(f'Testing if "{ip}" is a valid IP address')
# Check for exception when creating an ip_address object
try:
ip_address(ip)
except Exception as e:
logging.error(f'Could not validate string "{ip}" as an IP address: {e}')
return False
# IP provided is valid
return True
def __execute_ip(self, ip: str, format: str, type: str) -> Union[dict, str]:
"""Execute an API lookup for an IP address based provider (geographic information or provider information)
Parameters
----------
ip : str
The IP address to lookup
format : {'json', 'xml'}
The format for which results should be returned - json results will be returned as a dict
type : {'geo','provider'}
The API type to lookup ('geo' for geographic information or 'provider' for provider information)
Returns
-------
dict or str
The lookup result in either dict format (for JSON lookups) or string format (for XML lookups)
"""
# Make sure there is an endpoint for the requested type
if not self.endpoints['ip'][type]:
raise ValueError(f'Invalid lookup type "{type}" requested')
# Make sure that the format selected is valid
if format not in self.endpoints['ip'][type]['format']:
raise ValueError(f'The "{type}" API endpoint does not support the requested format "{format}"')
# Build the API URL that the request will be made to
url = f'{self.api}/{type}.{format}'
# Set the parameters for the request (this will add the API key if available)
params = self.__api_param({'ip': ip})
# Send API request
try:
response = self.__api_request(url = url, params = params)
except Exception as e:
logging.error('Failed to send API request: {e}')
raise RuntimeError('Could not run API lookup') from e
# Make sure content type of the response is expected
if response.headers.get('Content-Type') != f'application/{format}':
if response.headers.get('Content-Type'):
raise RuntimeError(f'Expecting Content-Type header "application/{format}" but got "{req.headers.get("Content-Type")}"')
else:
raise RuntimeError(f'API request did not provide any Content-Type header')
# If the format requests is XML, return it immediately otherwise attempt to parse the json response into a dict
if format == 'xml':
return response.text
elif format == 'json':
try:
json = response.json()
except Exception as e:
raise RuntimeError('Exception parsing response from API as json') from e
return json
else:
raise RuntimeError(f'No output handler configured for the output format "{format}"')
def geo(self, ip: str, format: str = 'json', force: bool = False, cache: bool = True) -> Union[dict, str]:
"""Perform a Geographic information lookup to the 2ip API.
By default, lookups will be cached. Subsequent lookups will use the cache (unless disabled) to prevent excessive API requests.
Parameters
----------
ip : str
The IP address to lookup
format : {'xml','json'}
The requested output format - JSON will result in a dict otherwise XML will result in a str
force : bool, default = False
Force request to be sent to the API even if the lookup has already been cached
cache: bool, default = True
Allow caching of the request (cache can still be bypassed by using the force parameter)
Returns
-------
dict or str
The response from API in either a dictionary (if the format is set to json) or a string (if the format is set to XML)
Raises
------
ValueError
Invalid IP address or invalid output format requested
RuntimeError
API request failure
Examples
--------
>>> twoip = TwoIP(key = '12345678')
>>> twoip.geo(ip = '192.0.2.0')
{'ip': '192.0.2.0', 'country_code': '-', 'country': '-', 'country_rus': 'Неизвестно', 'country_ua': 'Невідомо',
'region': '-', 'region_rus': 'Неизвестно', 'region_ua': 'Невідомо', 'city': '-', 'city_rus': 'Неизвестно',
'city_ua': 'Невідомо', 'zip_code': '-', 'time_zone': '-'}
"""
# Make sure IP address provided is valid
if self.__test_ip(ip = ip):
logging.debug(f'2ip geo API lookup request for IP "{ip}" (force: {force})')
else:
raise ValueError(f'Could not run geo lookup for invalid IP address "{ip}"')
# If the lookup is cached and this is not a forced lookup, return the cached result
if ip in self.__cache['geo'][format]:
logging.debug(f'Cached API entry available for IP "{ip}"')
if force:
logging.debug('Cached entry will be ignored for lookup; proceeding with API request')
else:
logging.debug('Cached entry will be returned; use the force parameter to force API request')
return self.__cache['geo'][format][ip]
# Run the request
response = self.__execute_ip(ip = ip, format = format, type = 'geo')
# Cache the response if allowed
if cache:
self.__cache['geo'][format][ip] = response
# Return response
return response
def provider(self, ip: str, format: str = 'json', force: bool = False, cache: bool = True) -> Union[dict, str]:
"""Perform a provider information lookup to the 2ip API.
By default, lookups will be cached. Subsequent lookups will use the cache (unless disabled) to prevent excessive API requests.
Parameters
----------
ip : str
The IP address to lookup
format : {'xml','json'}
The requested output format - JSON will result in a dict otherwise XML will result in a str
force : bool, default = False
Force request to be sent to the API even if the lookup has already been cached
cache: bool, default = True
Allow caching of the request (cache can still be bypassed by using the force parameter)
Returns
-------
dict or str
The response from API in either a dictionary (if the format is set to json) or a string (if the format is set to XML)
Raises
------
ValueError
Invalid IP address or invalid output format requested
RuntimeError
API request failure
Examples
--------
>>> twoip = TwoIP(key = '12345678')
>>> twoip.provider(ip = '192.0.2.0')
{'ip': '192.0.2.0', 'name_ripe': 'Reserved AS', 'name_rus': '', 'ip_range_start': '3221225984', 'ip_range_end': '3221226239',
'route': '192.0.2.0', 'mask': '24'}
"""
# Make sure IP address provided is valid
if self.__test_ip(ip = ip):
logging.debug(f'2ip provider API lookup request for IP "{ip}" (force: {force})')
else:
raise ValueError(f'Could not run provider lookup for invalid IP address "{ip}"')
# If the lookup is cached and this is not a forced lookup, return the cached result
if ip in self.__cache['provider'][format]:
logging.debug(f'Cached API entry available for IP "{ip}"')
if force:
logging.debug('Cached entry will be ignored for lookup; proceeding with API request')
else:
logging.debug('Cached entry will be returned; use the force parameter to force API request')
return self.__cache['provider'][format][ip]
# Run the request
response = self.__execute_ip(ip = ip, format = format, type = 'provider')
# Cache the response if allowed
if cache:
self.__cache['provider'][format][ip] = response
# Return response
return response | 2ip | /2ip-0.0.2.tar.gz/2ip-0.0.2/twoip/twoip.py | twoip.py |
##########
2lazy2rest
##########
A simple way to produce short-to-medium document using *reStructuredText*
Multi-format themes
Render the same document in HTML, ODT, PDF keeping the main visual identity
Unified interface
- Tired of switching between rst2* tools having different arguments or behavior ?
- Would like to not lose *code-blocks* or some rendering options switching the output format ?
This tool try to address this
Make your own theme
TODO: templates will be customizable easily (say, probably colors only)
How to use it
#############
Dependencies
============
You'll need **rst2pdf** to use all the features, other rst2* tools are coming from docutils.
Using
=====
.. code-block:: console
mkrst [-h] [--html] [--pdf] [--odt] [--theme THEME]
[--themes-dir THEMES_DIR]
FILE
optional arguments:
-h, --help show this help message and exit
--html Generate HTML output
--pdf Generate PDF output
--odt Generate ODT output
--theme THEME Use a different theme
--themes-dir THEMES_DIR
Change the folder searched for theme
.. code-block:: console
popo:~/2lazy2rest% ./mkrst test_page.rst --html --pdf
Using ./themes/default
html: test_page.html
pdf: test_page.pdf
Customizing
===========
Make a copy of ``themes/default``, edit to your needs the copy and use the **--theme** option with the name of your copy, that's All !
Example
-------
.. code-block:: console
popo:~/2lazy2rest% cp -r themes/default themes/red
popo:~/2lazy2rest% sed -si 's/#FEFEFE/red/g' themes/red/html/stylesheet.css
popo:~/2lazy2rest% ./mkrst test_page.rst --html --theme red
Issues
######
- ODT style is unfinished
- PDF & HTML still needs more ReST coverage
- No skin generation from template yet
| 2lazy2rest | /2lazy2rest-0.2.2.tar.gz/2lazy2rest-0.2.2/README.rst | README.rst |
from __future__ import absolute_import, print_function
import argparse
import importlib.util
import os
import subprocess
import mkrst_themes
THEMES_DIR = os.path.dirname(mkrst_themes.__file__)
THEME = "default"
SUPPORTED_FORMATS = "html pdf odt".split()
DEBUG = "DEBUG" in os.environ
class CommandExecutor:
GENERAL_OPTIONS = ["--syntax-highlight=short", "--smart-quotes=yes"]
def __init__(self, opts: argparse.Namespace):
self._src: str = opts.input
self._verbose: bool = opts.verbose
self._extensions: str = opts.ext
def set_theme(self, path: str, name: str) -> None:
if os.path.exists(name):
self.theme_dir = os.path.abspath(name)
else:
self.theme_dir = os.path.join(path, name)
print("Using %s" % self.theme_dir)
def _list_resources(self, origin: str, extension: str) -> list[str]:
r = []
for fname in os.listdir(os.path.join(self.theme_dir, origin)):
if fname.endswith(extension):
r.append(os.path.join(self.theme_dir, origin, fname))
r.sort()
if DEBUG:
print("List(*%s) = %s" % (extension, ", ".join(r)))
return r
def get_output(self, fmt: str) -> str:
return self._src.rsplit(".", 1)[0] + "." + fmt
def __execute(self, args: list[str]) -> None | tuple[bytes, bytes]:
if DEBUG:
print("Executing %s" % " ".join(args))
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = proc.communicate()
def show_result() -> None:
print("\nStdout:")
print(out.decode("utf-8").strip())
print("\nStderr:")
print(err.decode("utf-8").strip())
if proc.returncode == 0:
if self._verbose:
show_result()
return (out, err)
else:
print(" PROBLEM! ".center(80, "#"))
show_result()
return None
def make_pdf(self) -> None:
out = self.get_output("pdf")
opts = [o for o in self.GENERAL_OPTIONS if "syntax" not in o]
opts += ["--font-path", os.path.join(self.theme_dir, "fonts")]
args = [
"rst2pdf",
"--fit-background-mode=scale",
"--use-floating-images",
"--real-footnotes",
"-e",
"preprocess",
] + opts
for style in self._list_resources("pdf", ".yaml"):
args.extend(("-s", style))
if self._extensions:
args.extend(("-e", self._extensions))
args.extend(("-o", out, self._src))
if self.__execute(args):
print(out)
def make_odt(self) -> None:
out = self.get_output("odt")
css = self._list_resources("odt", "odt")[0]
args = ["rst2odt"] + self.GENERAL_OPTIONS + ["--add-syntax-highlighting", "--stylesheet", css, self._src, out]
if self.__execute(args):
print(out)
def make_html(self) -> None:
out = self.get_output("html")
css = ",".join(self._list_resources("html", "css"))
args = ["rst2html"] + self.GENERAL_OPTIONS + ["--embed-stylesheet", "--stylesheet-path", css, self._src, out]
if self.__execute(args):
print(out)
# post process
links = os.path.join(self.theme_dir, "html", "links.html")
if os.path.exists(links):
data = open(out).read()
data = data.replace("<html>", "<html>\n" + open(links).read())
open(out, "w").write(data)
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", action="store_true", help="Display commands' output")
parser.add_argument(
"input",
type=str,
metavar="FILE",
nargs="?",
help="The .rst or .txt file to convert",
)
for fmt in SUPPORTED_FORMATS:
parser.add_argument("--%s" % fmt, action="store_true", help="Generate %s output" % fmt.upper())
parser.add_argument("-t", "--theme", type=str, default=THEME, help="Use a different theme")
parser.add_argument(
"--themes-dir",
type=str,
default=THEMES_DIR,
help="Change the folder searched for theme",
)
parser.add_argument("--ext", type=str, default="", help="Load docutils extensions (coma separated)")
parser.add_argument("-l", "--list", action="store_true", help="List available themes")
args = parser.parse_args()
cmd = CommandExecutor(args)
cmd.set_theme(args.themes_dir, args.theme)
if args.list:
for t in os.listdir(THEMES_DIR):
if t[0] not in "_." and os.path.isdir(os.path.join(THEMES_DIR, t)):
print(t)
elif not any(getattr(args, fmt) for fmt in SUPPORTED_FORMATS):
print("No action ! Give one or more --(%s)" % "|".join(SUPPORTED_FORMATS))
else:
if not args.input:
print("No input file !")
else:
for fmt in SUPPORTED_FORMATS:
if getattr(args, fmt):
fn = getattr(cmd, "make_%s" % fmt)
print(" %5s: " % fmt, end="")
fn()
if __name__ == "__main__":
main() | 2lazy2rest | /2lazy2rest-0.2.2.tar.gz/2lazy2rest-0.2.2/mkrst/__init__.py | __init__.py |
This is a continually-updated market data analysis machine learning transformer model intended for summarizing & interpreting market & economic data.
To use:
1. gh repo clone sscla1/2op_ai
2. install requirements.txt wherever running your application
3. import statement: from 2op_ai import ai_pipeline
4. use case for summarizer & interpreter
def summarize_text(self, text):
"""
Summarizes the provided text.
Args:
text (str): The text to be summarized.
Returns:
str: The summarized text.
"""
try:
# Perform text summarization using AI pipeline
summary = self.ai_pipeline(text, max_length=600)[0]['summary_text']
return summary
except Exception as e:
logging.error(f"An error occurred when trying to summarize text: {e}")
return ""
def generate_interpretation(self, summary):
"""
Generates interpretation for the summary using the AI pipeline.
Args:
summary (str): The summary to generate interpretation for.
Returns:
str or None: The generated interpretation or None if an error occurs.
"""
logging.info("Attempting to generate interpretation.")
try:
input_text = "Explain the provided data, its affect on the market, and specific sectors, in layman's terms, in 300 words or less: " + summary
interpretation = self.ai(input_text, max_length=300, do_sample=True)[0]['generated_text']
return interpretation
except Exception as e:
logging.error(f"An error occurred when trying to generate interpretation: {e}")
return None | 2op-ai | /2op_ai-0.1.tar.gz/2op_ai-0.1/README.md | README.md |
import logging
import os
import pandas as pd
import nbformat
from nbconvert import PythonExporter
import chardet
import pdb
class DataProcessor:
def __init__(self, data_dir):
# Initialize the data directory and logger
self.data_dir = data_dir
self.logger = self.setup_logging()
def setup_logging(self):
# Set up logging with both console and file handlers
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
log_file_path = os.path.join(self.data_dir, "data_processing.log")
file_handler = logging.FileHandler(log_file_path)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
def export_notebook_to_script(self, notebook_path, script_path):
# Export Jupyter Notebook to a Python script
nb = nbformat.read(notebook_path, as_version=nbformat.NO_CONVERT)
exporter = PythonExporter()
python_code, _ = exporter.from_notebook_node(nb)
with open(script_path, "w") as f:
f.write(python_code)
def load_csv(self, file_path, encoding='utf-8', dtype=None):
# Load CSV file with error handling for different encodings
try:
with open(file_path, 'rb') as f:
result = chardet.detect(f.read())
file_encoding = result['encoding']
return pd.read_csv(file_path, encoding=file_encoding, dtype=dtype, low_memory=False)
except UnicodeDecodeError:
self.logger.warning(f"UnicodeDecodeError encountered while loading CSV '{file_path}' with encoding '{encoding}'. Trying 'latin-1' encoding.")
try:
return pd.read_csv(file_path, encoding='latin-1', dtype=dtype, low_memory=False)
except Exception as e:
self.logger.error(f"Error loading CSV '{file_path}' with 'latin-1' encoding: {e}")
return None
except Exception as e:
self.logger.error(f"Error loading CSV '{file_path}': {e}")
return None
def load_excel(self, file_path, encoding='utf-8'):
# Load Excel file with error handling for different encodings
try:
return pd.read_excel(file_path, engine='openpyxl')
except UnicodeDecodeError:
self.logger.warning(f"UnicodeDecodeError encountered while loading Excel '{file_path}' with encoding '{encoding}'. Trying 'latin-1' encoding.")
try:
return pd.read_excel(file_path, engine='openpyxl', encoding='latin-1')
except Exception as e:
self.logger.error(f"Error loading Excel '{file_path}' with 'latin-1' encoding: {e}")
return None
except Exception as e:
self.logger.error(f"Error loading Excel '{file_path}': {e}")
return None
def process_sroie_files(self, directory):
# Process SROIE files from the given directory
sroie_data = []
for root, _, files in os.walk(directory):
for file in files:
if file.endswith('.txt'):
file_path = os.path.join(root, file)
try:
with open(file_path, 'rb') as txt_file:
raw_data = txt_file.read()
detected_encoding = chardet.detect(raw_data)['encoding']
text_data = raw_data.decode(detected_encoding)
sroie_data.append(text_data)
except Exception as e:
self.logger.error(f"Error reading '{file_path}': {e}")
sroie_df = pd.DataFrame({'data': sroie_data})
return sroie_df
def process_data(self):
# Process various data files and concatenate them into a single dataset
try:
breakpoint()
root_dir = os.path.join(self.data_dir)
# Load files
currency_data = self.load_csv(os.path.join(root_dir, 'currency.csv'))
fortune500_data = self.load_csv(os.path.join(root_dir, 'fortune500.csv'))
msft_data = self.load_csv(os.path.join(root_dir, 'msft.csv'))
snp_data = self.load_csv(os.path.join(root_dir, 's&p.csv'))
balancesheets_data = self.load_csv(os.path.join(root_dir, 'bank_fail', 'balancesheets.csv'))
banklist_data = self.load_csv(os.path.join(root_dir, 'bank_fail', 'banklist.csv'))
final_datasets_dir = os.path.join(root_dir, 'income', 'final_datasets')
final_datasets_files = [
'Final_32_region_deciles_1958-2015.csv',
'Final_Global_Income_Distribution.csv',
'Final_Historical_data_ISO.csv'
]
final_datasets_data = pd.concat(
[pd.read_csv(os.path.join(final_datasets_dir, file)) for file in final_datasets_files]
)
input_data_dir = os.path.join(root_dir, 'income', 'input_data')
input_data_files = [
'WDI_GINI_data.csv'
]
input_data = pd.concat(
[pd.read_csv(os.path.join(input_data_dir, file)) for file in input_data_files]
)
mapping_files_dir = os.path.join(root_dir, 'income', 'mapping_files')
mapping_files_files = [
'GCAM_region_names.csv',
'WIDER_mapping_file.csv'
]
mapping_files = pd.concat(
[pd.read_csv(os.path.join(mapping_files_dir, file)) for file in mapping_files_files]
)
train_dataset = pd.concat([currency_data, fortune500_data, msft_data, snp_data,
balancesheets_data, banklist_data, final_datasets_data,
input_data, mapping_files])
etfs_dir = os.path.join(root_dir, 'nasdaq', 'etfs')
etfs_files = [file for file in os.listdir(etfs_dir) if file.endswith('.csv')]
etfs_data = pd.concat([pd.read_csv(os.path.join(etfs_dir, file)) for file in etfs_files])
stocks_dir = os.path.join(root_dir, 'nasdaq', 'stocks')
stocks_files = [file for file in os.listdir(stocks_dir) if file.endswith('.csv')]
stocks_data = pd.concat([pd.read_csv(os.path.join(stocks_dir, file)) for file in stocks_files])
symbols_valid_meta_data = self.load_csv(os.path.join(root_dir, 'nasdaq', 'symbols_valid_meta.csv'))
train_dataset = pd.concat([train_dataset, etfs_data, stocks_data, symbols_valid_meta_data])
news_dir = os.path.join(root_dir, 'news')
news_files = [file for file in os.listdir(news_dir) if file.endswith('.csv')]
news_data = pd.concat([pd.read_csv(os.path.join(news_dir, file)) for file in news_files])
train_dataset = pd.concat([train_dataset, news_data])
prediction_dir = os.path.join(root_dir, 'prediction')
prediction_files = [file for file in os.listdir(prediction_dir) if file.endswith('.csv')]
prediction_data = pd.concat([pd.read_csv(os.path.join(prediction_dir, file)) for file in prediction_files])
train_dataset = pd.concat([train_dataset, prediction_data])
sroie_dir = os.path.join(root_dir, 'sroie')
sroie_df = self.process_sroie_files(sroie_dir)
breakpoint()
train_dataset = pd.concat([train_dataset, sroie_df]) # Concatenate sroie_df with the train_dataset
self.logger.info("Data processing completed successfully.")
return train_dataset
except Exception as e:
self.logger.error(f"An error occurred during data processing: {e}")
return None
if __name__ == "__main__":
script_dir = os.path.dirname(os.path.abspath(__file__))
project_dir = os.path.dirname(script_dir)
data_dir = os.path.join(project_dir, "training_data")
data_processor = DataProcessor(data_dir)
currency_data = data_processor.load_csv(os.path.join(data_processor.data_dir, 'currency.csv'))
print("Currency Data:", currency_data)
fortune500_data = data_processor.load_csv(os.path.join(data_processor.data_dir, 'fortune500.csv'))
print("Fortune500 Data:", fortune500_data)
msft_data = data_processor.load_csv(os.path.join(data_processor.data_dir, 'msft.csv'))
print("MSFT Data:", msft_data)
snp_data = data_processor.load_csv(os.path.join(data_processor.data_dir, 's&p.csv'))
print("S&P Data:", snp_data)
breakpoint()
trained_dataset = data_processor.process_data()
if trained_dataset is not None:
print("Data processing completed successfully.")
trained_dataset.to_csv(os.path.join(data_dir, "trained_dataset.csv"), index=False)
else:
print("Data processing failed.") | 2op-ai | /2op_ai-0.1.tar.gz/2op_ai-0.1/src/processing.py | processing.py |
import os
import logging
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from processing import DataProcessor
from finetuning import finetune_model
def main():
# Get the directory of the currently executing script
script_dir = os.path.dirname(os.path.abspath(__file__))
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
try:
# Instantiate the tokenizer and model
tokenizer = AutoTokenizer.from_pretrained("Salesforce/xgen-7b-8k-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("Salesforce/xgen-7b-8k-base", torch_dtype=torch.bfloat16)
# Set up fine-tuning parameters
num_epochs = 10
batch_size = 16
learning_rate = 1e-5
# Construct the project directory path using the script's directory
project_dir = os.path.dirname(script_dir)
data_dir = os.path.join(project_dir, "training_data")
print("Instantiating DataProcessor...")
data_processor = DataProcessor(data_dir)
print("Processing data...")
trained_dataset = data_processor.process_data() # Only train dataset for fine-tuning
if trained_dataset is not None:
# Calculate validation dataset (val_dataset) for fine-tuning
val_dataset = trained_dataset.sample(frac=0.2, random_state=42)
trained_dataset.to_csv(os.path.join(data_dir, "trained_dataset.csv"), index=False)
else:
logging.error("Data processing failed.")
return
# Fine-tune the model using the imported function
print("Fine-tuning model...")
finetune_model(model, trained_dataset, val_dataset, num_epochs, batch_size, learning_rate)
logging.info("Fine-tuning completed successfully.")
# Example usage for aipipeline, summarizer, and interpreter
from transformers import pipeline, TextGenerationPipeline
# Create an AI pipeline
aipipeline = pipeline("text-generation", model=model, tokenizer=tokenizer)
# Summarizer
summarizer = TextGenerationPipeline(model=model, tokenizer=tokenizer)
# Interpreter
def interpret(text):
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)
predicted_class = torch.argmax(outputs.logits, dim=-1).item()
return predicted_class
except Exception as e:
logging.error(f"An error occurred: {e}")
raise
if __name__ == "__main__":
main() | 2op-ai | /2op_ai-0.1.tar.gz/2op_ai-0.1/src/main.py | main.py |
import logging
import os
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from processing import DataProcessor
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
def finetune_model(model, train_dataset, val_dataset, num_epochs, batch_size, learning_rate):
try:
# Instantiate the tokenizer with the unk_token set
tokenizer = AutoTokenizer.from_pretrained(
"Salesforce/xgen-7b-8k-base",
unk_token="<unk>", # Set the unk_token
trust_remote_code=True
)
# Enable token tracing
tokenizer._tokenizer.enable_tracing()
# Set up the optimizer and loss function, data loaders, and fine-tuning loop
optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
loss_fn = torch.nn.CrossEntropyLoss()
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size)
# Fine-tuning loop
for epoch in range(num_epochs):
model.train()
for inputs, labels in train_loader:
optimizer.zero_grad()
# Tokenize the text using the tokenizer
tokenized_inputs = tokenizer(inputs, return_tensors="pt", padding=True, truncation=True)
outputs = model(**tokenized_inputs)
logits = outputs.logits
loss = loss_fn(logits, labels)
loss.backward()
optimizer.step()
model.eval()
with torch.no_grad():
total_loss = 0.0
total_correct = 0
total_samples = 0
for inputs, labels in val_loader:
# Tokenize the text using the tokenizer
tokenized_inputs = tokenizer(inputs, return_tensors="pt", padding=True, truncation=True)
outputs = model(**tokenized_inputs)
logits = outputs.logits
loss = loss_fn(logits, labels)
total_loss += loss.item()
_, predicted = torch.max(logits, 1)
total_correct += (predicted == labels).sum().item()
total_samples += labels.size(0)
# Calculate val_loss and val_accuracy
val_loss = total_loss / len(val_loader)
val_accuracy = total_correct / total_samples
logging.info(f"Epoch {epoch+1}: Val Loss = {val_loss:.4f}, Val Accuracy = {val_accuracy:.4f}")
# Disable token tracing
tokenizer._tokenizer.disable_tracing()
except Exception as e:
logging.error(f"An error occurred during fine-tuning: {e}")
raise
if __name__ == "__main__":
# Get the directory of the currently executing script
script_dir = os.path.dirname(os.path.abspath(__file__))
# Construct the project directory path using the script's directory
project_dir = os.path.dirname(script_dir)
data_dir = os.path.join(project_dir, "training_data") # Construct the data directory path
# Instantiate the DataProcessor class
data_processor = DataProcessor(data_dir)
# Load and process the datasets
trained_dataset = data_processor.process_data()
if trained_dataset is not None:
# Calculate batch size and learning rate
batch_size = 32
num_samples = len(trained_dataset)
num_epochs = 5
learning_rate = 1e-4
# Calculate validation dataset (val_dataset) for fine-tuning
val_dataset = trained_dataset.sample(frac=0.2, random_state=42)
# Instantiate the model for fine-tuning
model = AutoModelForCausalLM.from_pretrained("Salesforce/xgen-7b-8k-base")
# Fine-tune the model using the train_dataset and val_dataset
finetune_model(model, trained_dataset, val_dataset, num_epochs, batch_size, learning_rate)
logging.info("Fine-tuning completed successfully.")
else:
logging.error("Data processing failed.") | 2op-ai | /2op_ai-0.1.tar.gz/2op_ai-0.1/src/finetuning.py | finetuning.py |
__version__ = '0.1.0'
import os
import sys
import re
# TODO use ast
# TODO use 2to3
# TODO use pyflakes
def classify_string(s):
"Returns 2 or 3 based on a string s of Python source code, defaulting to 3"
first_line = s.splitlines()[0]
if '#!' in first_line:
if 'python3' in first_line:
return 3
elif 'python2' in first_line:
return 2
if 'yield from' in s:
return 3
if 'Error, e' in s:
return 2
if 'xrange' in s:
return 2
if (re.search(r'''u"[^"]*"[.]decode''', s) or
re.search(r'''u'[^']*'[.]decode''', s) or
re.search(r'''b"[^"]*"[.]encode''', s) or
re.search(r'''b'[^']*'[.]encode''', s)):
return 2
return 3
def has_pycache(filename):
"Returns bool for if there exists a __pycache__ directory next to a file"
neighbors = os.listdir(os.path.dirname(os.path.abspath(filename)))
if '__pycache__' in neighbors:
return True
else:
return False
def pycache_classify(filename):
"""Returns 3, 2, or None for prediction from __pycache__ directory
prefers 3 if both found, returns None if neither found"""
dirname, name = os.path.split(os.path.abspath(filename))
neighbors = os.listdir(dirname)
if '__pycache__' in neighbors:
classifications = [
n[-6:-5]
for n in os.listdir(os.path.join(dirname, '__pycache__'))
if n.split('.', 1)[0] == name.split('.', 1)[0]]
if '3' in classifications:
return 3
elif '2' in classifications:
return 2
return None
def classify(filename):
r = pycache_classify(filename)
if r:
return r
return classify_string(open(filename).read())
def main(error_if_not=None):
"""Writes 2 or 3 and a newline to stdout, uses exit code for error_if_not"""
r = classify(sys.argv[-1])
print r
if error_if_not is not None:
sys.exit(0 if r == error_if_not else r)
if __name__ == '__main__':
main() | 2or3 | /2or3-0.1.0.tar.gz/2or3-0.1.0/lib2or3/__init__.py | __init__.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import java.io as _jio
# noinspection PyUnresolvedReferences
import java.nio.file as _jnio_file
from io import IOBase, SEEK_SET
from typing import Union
InputStream = _jio.InputStream
Reader = _jio.Reader
InputStreamReader = _jio.InputStreamReader
BufferedReader = _jio.BufferedReader
Files = _jnio_file.Files
Paths = _jnio_file.Paths
@jpype.JImplementationFor("java.io.InputStream")
class _JvmInputStream:
def __jclass_init__(cls):
IOBase.register(cls)
@jpype.JOverride
def close(self):
self._closed = True
self.close_()
@property
def closed(self):
if hasattr(self, '_closed'):
return self._closed
else:
return False
def fileno(self):
raise OSError("This IOBase is backed by an instance of <java.io.InputStream>")
def flush(self):
pass
def isatty(self):
return False
def readable(self):
return True
def seekable(self):
return False
def writable(self):
return False
def _buffer(self):
if not hasattr(self, '_buffered'):
self._buffered = BufferedReader(InputStreamReader(self))
def readline(self, size=-1):
self._buffer()
self._buffered.readLine()
def readlines(self, hint=-1):
self._buffer()
stream = self._buffered.read.lines()
if hint >= 0:
stream = stream.limit(hint)
return list(stream)
def seek(self, offset: int, whence=SEEK_SET):
raise OSError("This IOBase is backed by an instance of <java.io.InputStream>")
def tell(self):
raise OSError("This IOBase is backed by an instance of <java.io.InputStream>")
def truncate(self, size=None):
raise OSError("This IOBase is backed by an instance of <java.io.InputStream>")
def writelines(self):
raise OSError("This IOBase is backed by an instance of <java.io.InputStream>")
def open_file(path: str) -> InputStream:
return Files.newInputStream(Paths.get(path))
def ensure_input_steam(input: Union[str, InputStream]) -> InputStream:
if isinstance(input, str):
return open_file(input)
elif isinstance(input, InputStream):
return input
else:
raise TypeError("Invalid type: " + type(input))
logger.debug("Configure JVM-specific IO extensions") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/jvmioutils.py | jvmioutils.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyProtectedMember
from _jpype import _JObject as JObjectClass
# noinspection PyUnresolvedReferences
import java.util as _jutils
# noinspection PyUnresolvedReferences
import java.lang as _jlang
# noinspection PyUnresolvedReferences
import kotlin as _kotlin
# noinspection PyUnresolvedReferences
import kotlin.sequences as _ksequences
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.utils as _tuprolog_utils
from typing import Iterable as PyIterable
from typing import Iterator as PyIterator
from typing import Mapping, MutableMapping, Callable, Any
from .jvmioutils import *
Arrays = _jutils.Arrays
ArrayList = _jutils.ArrayList
Iterator = _jutils.Iterator
Map = _jutils.Map
NoSuchElementException = _jutils.NoSuchElementException
Iterable = _jlang.Iterable
JavaSystem = _jlang.System
Object = _jlang.Object
Pair = _kotlin.Pair
Triple = _kotlin.Triple
Sequence = _ksequences.Sequence
SequencesKt = _ksequences.SequencesKt
PyUtils = _tuprolog_utils.PyUtils
def protect_iterable(iterable: Iterable) -> Iterable:
return PyUtils.iterable(iterable)
@jpype.JImplements("java.util.Iterator", deferred=True)
class _IteratorAdapter(object):
def __init__(self, iterator):
assert isinstance(iterator, PyIterator)
self._iterator = iterator
self._queue = None
@jpype.JOverride
def hasNext(self):
if self._queue is None:
try:
self._queue = [next(self._iterator)]
return True
except StopIteration:
return False
elif len(self._queue) > 0:
return True
else:
try:
self._queue.append(next(self._iterator))
return True
except StopIteration:
return False
@jpype.JOverride
def next(self):
if self.hasNext():
return self._queue.pop(0)
else:
raise NoSuchElementException()
@jpype.JImplements("java.lang.Iterable", deferred=True)
class _IterableAdapter(object):
def __init__(self, iterable):
assert isinstance(iterable, PyIterable)
self._iterable = iterable
@jpype.JOverride
def iterator(self):
return _IteratorAdapter(iter(self._iterable))
def kpair(items: PyIterable) -> Pair:
if isinstance(items, Pair):
return items
i = iter(items)
first = next(i)
second = next(i)
return Pair(first, second)
@jpype.JConversion("kotlin.Pair", instanceof=PyIterable, excludes=str)
def _kt_pair_covert(jcls, obj):
return kpair(obj)
def ktriple(items: PyIterable) -> Triple:
if isinstance(items, Triple):
return items
i = iter(items)
first = next(i)
second = next(i)
third = next(i)
return Triple(first, second, third)
@jpype.JConversion("kotlin.Triple", instanceof=PyIterable, excludes=str)
def _kt_triple_covert(jcls, obj):
return ktriple(obj)
def jlist(iterable: PyIterable) -> Iterable:
assert isinstance(iterable, PyIterable)
if isinstance(iterable, list):
return Arrays.asList(iterable)
lst = ArrayList()
for item in iterable:
lst.add(item)
return lst
def jiterable(iterable: PyIterable) -> Iterable:
assert isinstance(iterable, PyIterable)
return _IterableAdapter(iterable)
@jpype.JConversion("java.lang.Iterable", instanceof=PyIterable, excludes=str)
def _java_iterable_convert(jcls, obj):
return jiterable(obj)
def jarray(type, rank: int = 1):
return jpype.JArray(type, rank)
def jiterator(iterator: PyIterator) -> Iterator:
assert isinstance(iterator, PyIterator)
return _IteratorAdapter(iterator)
def jmap(dictionary: Mapping) -> Map:
assert isinstance(dictionary, Mapping)
return Map@dictionary
def _java_obj_repr(java_object: Object) -> str:
return str(java_object.toString())
# replaces the default __repr__ implementation for java objects, making them use _java_obj_repr
JObjectClass.__repr__ = _java_obj_repr
@jpype.JImplementationFor("kotlin.sequences.Sequence")
class _KtSequence:
def __jclass_init__(self):
PyIterable.register(self)
def __iter__(self):
return protect_iterable(self).iterator()
def ksequence(iterable: PyIterable) -> Sequence:
return SequencesKt.asSequence(jiterable(iterable))
@jpype.JConversion("kotlin.sequences.Sequence", instanceof=PyIterable, excludes=str)
def _kt_sequence_convert(jcls, obj):
return ksequence(obj)
@jpype.JImplementationFor("java.util.stream.Stream")
class _JvmStream:
def __jclass_init__(self):
PyIterable.register(self)
def __iter__(self):
return self.iterator()
@jpype.JImplementationFor("java.lang.Comparable")
class _JvmComparable:
def __jclass_init__(self):
pass
def __lt__(self, other):
return self.compareTo(other) < 0
def __gt__(self, other):
return self.compareTo(other) > 0
def __le__(self, other):
return self.compareTo(other) <= 0
def __ge__(self, other):
return self.compareTo(other) >= 0
@jpype.JImplementationFor("java.lang.Throwable")
class _JvmThrowable:
def __jclass_init__(self):
pass
@property
def message(self):
return self.getMessage()
@property
def localized_message(self):
return self.getLocalizedMessage()
@property
def cause(self):
return self.getCause()
class _KtFunction(Callable):
def __init__(self, arity: int, function: Callable):
self._function = function
self._arity = arity
def invoke(self, *args):
assert len(args) == self._arity
return self._function(*args)
def __call__(self, *args):
return self.invoke(*args)
_kt_function_classes: MutableMapping[int, Any] = dict()
def kfunction(arity: int):
if arity not in _kt_function_classes:
@jpype.JImplements("kotlin.jvm.functions.Function" + str(arity), deferred=True)
class _KtFunctionN(_KtFunction):
def __init__(self, f):
super().__init__(arity, f)
@jpype.JOverride
def invoke(self, *args):
return super().invoke(*args)
_kt_function_classes[arity] = _KtFunctionN
return _kt_function_classes[arity]
logger.debug("Configure JVM-specific extensions") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/jvmutils.py | jvmutils.py |
from collections import Mapping
from itertools import chain
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype
from tuprolog.pyutils import iterable_or_varargs
@jpype.JImplementationFor("it.unibo.tuprolog.solve.SolverFactory")
class _KtSolverFactory:
def __jclass_init__(self):
pass
@jpype.JImplementationFor("it.unibo.tuprolog.solve.SolveOptions")
class _KtSolveOptions:
_static_keys = {'lazy', 'is_lazy', 'eager', 'is_eager', 'timeout', 'limit'}
def __jclass_init__(self):
Mapping.register(self)
@property
def is_lazy(self):
return self.isLazy()
@property
def is_eager(self):
return self.isEager()
@property
def timeout(self):
return self.getTimeout()
@property
def limit(self):
return self.getLimit()
@property
def options(self):
return self.getOptions()
def __len__(self):
return 4 + len(self.options)
def __iter__(self):
return chain(_KtSolveOptions._static_keys, self.options)
def __contains__(self, item):
return item in _KtSolveOptions._static_keys
def __getitem__(self, item, default=None):
if item in {'lazy', 'is_lazy'}:
return self.is_lazy
elif item in {'eager', 'is_eager'}:
return self.is_eager
elif item == 'timeout':
return self.timeout
elif item == 'limit':
return self.limit
elif item in self.options:
return self.options[item]
elif default is not None:
return default
return KeyError(f"No such option: {item}")
@jpype.JImplementationFor("it.unibo.tuprolog.solve.ExecutionContextAware")
class _KtExecutionContextAware:
def __jclass_init__(self):
pass
@property
def libraries(self):
return self.getLibraries()
@property
def flags(self):
return self.getFlags()
@property
def static_kb(self):
return self.getStaticKb()
@property
def dynamic_kb(self):
return self.getDynamicKb()
@property
def operators(self):
return self.getOperators()
@property
def input_channels(self):
return self.getInputChannles()
@property
def output_channels(self):
return self.getOutputChannles()
@property
def standard_output(self):
return self.getStandardOutput()
@property
def standard_input(self):
return self.getStandardInput()
@property
def standard_error(self):
return self.getStandardError()
@property
def warnings(self):
return self.getWarnings()
@jpype.JImplementationFor("it.unibo.tuprolog.solve.Solver")
class _KtSolver:
def __jclass_init__(self):
pass
@jpype.JOverride
def solve(self, goal, options=None):
if options is None:
return self.solve_(goal)
elif options.is_eager:
return self.solveList(goal, options)
else:
return self.solve_(goal, options)
@jpype.JOverride
def solve_once(self, goal, options=None):
if options is None:
return self.solveOnce(goal)
else:
return self.solveOnce(goal, options)
@jpype.JImplementationFor("it.unibo.tuprolog.solve.MutableSolver")
class _KtMutableSolver:
def __jclass_init__(self):
pass
def load_library(self, library):
return self.loadLibrary(library)
def unload_library(self, library):
return self.unloadLibrary(library)
def set_libraries(self, libraries):
return self.setLibraries(libraries)
def load_static_kb(self, theory):
return self.loadStaticKb(theory)
def load_static_clauses(self, *clauses):
return iterable_or_varargs(clauses, lambda cs: self.loadStaticClauses(cs))
def append_static_kb(self, theory):
return self.appendStaticKb(theory)
def reset_static_kb(self):
return self.resetStaticKb()
def load_dynamic_kb(self, theory):
return self.loadDynamicKb(theory)
def load_dynamic_clauses(self, *clauses):
return iterable_or_varargs(clauses, lambda cs: self.loadDynamicClauses(cs))
def append_dynamic_kb(self, theory):
return self.appendDynamicKb(theory)
def reset_dynamic_kb(self):
return self.resetDynamicKb()
def assert_a(self, clause):
return self.assertA(clause)
def assert_z(self, clause):
return self.assertZ(clause)
def retract_all(self, clause):
return self.retractAll(clause)
def set_flag(self, *args):
return self.setFlag(*args)
@property
def standard_output(self):
return self.getStandardOutput()
@property
def standard_input(self):
return self.getStandardInput()
@property
def standard_error(self):
return self.getStandardError()
@property
def warnings(self):
return self.getWarnings()
@standard_input.setter
def standard_input(self, channel):
return self.setStandardInput(channel)
@standard_output.setter
def standard_output(self, channel):
return self.setStandardOutput(channel)
@standard_error.setter
def standard_error(self, channel):
return self.setStandardError(channel)
@warnings.setter
def warnings(self, channel):
return self.setWarnings(channel)
@jpype.JImplementationFor("it.unibo.tuprolog.solve.Solution")
class _KtSolution:
def __jclass_init__(self):
pass
@property
def is_yes(self):
return self.isYes()
@property
def is_no(self):
return self.isNo()
@property
def is_halt(self):
return self.isHalt()
@property
def substitution(self):
return self.getSubstitution()
@property
def exception(self):
return self.getExecption()
@property
def solved_query(self):
return self.getSolvedQuery()
def clean_up(self):
return self.cleanUp()
def value_of(self, variable):
return self.valueOf(variable)
logger.debug("Configure Kotlin adapters for types in it.unibo.tuprolog.solve.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/_ktadapt.py | _ktadapt.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
from ._ktadapt import *
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve as _solve
from tuprolog.core import Indicator, Struct, Term, Substitution, EMPTY_UNIFIER, TermFormatter
from tuprolog.solve.exception import ResolutionException
from tuprolog.jvmutils import jlist, jmap, JavaSystem
from functools import singledispatch
from typing import Iterable, Mapping, Any
ExecutionContext = _solve.ExecutionContext
ExecutionContextAware = _solve.ExecutionContextAware
MutableSolver = _solve.MutableSolver
Signature = _solve.Signature
Solution = _solve.Solution
SolutionFormatter = _solve.SolutionFormatter
SolveOptions = _solve.SolveOptions
Solver = _solve.Solver
SolverFactory = _solve.SolverFactory
Time = _solve.Time
@singledispatch
def signature(name: str, arity: int, vararg: bool = False) -> Signature:
return Signature(name, arity, vararg)
@signature.register
def _signature_from_indicator(indicator: Indicator) -> Signature:
return Signature.fromIndicator(indicator)
@signature.register
def _signature_from_term(term: Term) -> Signature:
return Signature.fromSignatureTerm(term)
@singledispatch
def yes_solution(
signature: Signature,
arguments: Iterable[Term],
substitution: Substitution.Unifier = EMPTY_UNIFIER
) -> Solution.Yes:
return Solution.yes(signature, jlist(arguments), substitution)
@yes_solution.register
def _yes_solution_from_query(query: Struct, substitution: Substitution.Unifier = EMPTY_UNIFIER) -> Solution.Yes:
return Solution.yes(query, substitution)
@singledispatch
def no_solution(signature: Signature, arguments: Iterable[Term]) -> Solution.No:
return Solution.no(signature, jlist(arguments))
@no_solution.register
def _no_solution_from_query(query: Struct) -> Solution.No:
return Solution.no(query)
@singledispatch
def halt_solution(signature: Signature, arguments: Iterable[Term], exception: ResolutionException) -> Solution.Halt:
return Solution.halt(signature, jlist(arguments), exception)
@halt_solution.register
def _halt_solution_from_query(query: Struct, exception: ResolutionException) -> Solution.No:
return Solution.halt(query, exception)
def current_time_instant() -> int:
return JavaSystem.currentTimeMillis()
def solution_formatter(term_formatter: TermFormatter = TermFormatter.prettyExpressions()) -> SolutionFormatter:
return SolutionFormatter.of(term_formatter)
MAX_TIMEOUT: int = SolveOptions.MAX_TIMEOUT
ALL_SOLUTIONS: int = SolveOptions.ALL_SOLUTIONS
def solve_options(
lazy: bool = True,
timeout: int = MAX_TIMEOUT,
limit: int = ALL_SOLUTIONS,
custom: Mapping[str, Any] = dict(),
**kwargs: Any
) -> SolveOptions:
opts = dict(kwargs)
for key in custom:
opts[key] = custom[key]
temp = SolveOptions.of(lazy, timeout, limit)
if len(opts) > 0:
return temp.setOptions(jmap(opts))
return temp
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/__init__.py | __init__.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.stdlib.primitive as _primitive
Abolish = _primitive.Abolish.INSTANCE
Arg = _primitive.Arg.INSTANCE
ArithmeticEqual = _primitive.ArithmeticEqual.INSTANCE
ArithmeticGreaterThan = _primitive.ArithmeticGreaterThan.INSTANCE
ArithmeticGreaterThanOrEqualTo = _primitive.ArithmeticGreaterThanOrEqualTo.INSTANCE
ArithmeticLowerThan = _primitive.ArithmeticLowerThan.INSTANCE
ArithmeticLowerThanOrEqualTo = _primitive.ArithmeticLowerThanOrEqualTo.INSTANCE
ArithmeticNotEqual = _primitive.ArithmeticNotEqual.INSTANCE
Assert = _primitive.Assert.INSTANCE
AssertA = _primitive.AssertA.INSTANCE
AssertZ = _primitive.AssertZ.INSTANCE
Atom = _primitive.Atom.INSTANCE
AtomChars = _primitive.AtomChars.INSTANCE
AtomCodes = _primitive.AtomCodes.INSTANCE
AtomConcat = _primitive.AtomConcat.INSTANCE
AtomLength = _primitive.AtomLength.INSTANCE
Atomic = _primitive.Atomic.INSTANCE
BagOf = _primitive.BagOf.INSTANCE
Between = _primitive.Between.INSTANCE
Callable = _primitive.Callable.INSTANCE
CharCode = _primitive.CharCode.INSTANCE
Clause = _primitive.Clause.INSTANCE
Compound = _primitive.Compound.INSTANCE
CopyTerm = _primitive.CopyTerm.INSTANCE
CurrentFlag = _primitive.CurrentFlag.INSTANCE
CurrentOp = _primitive.CurrentOp.INSTANCE
EnsureExecutable = _primitive.EnsureExecutable.INSTANCE
FindAll = _primitive.FindAll.INSTANCE
Float = _primitive.Float.INSTANCE
Functor = _primitive.Functor.INSTANCE
GetDurable = _primitive.GetDurable.INSTANCE
GetEphemeral = _primitive.GetEphemeral.INSTANCE
GetPersistent = _primitive.GetPersistent.INSTANCE
Ground = _primitive.Ground.INSTANCE
Halt = _primitive.Halt.INSTANCE
Halt1 = _primitive.Halt1.INSTANCE
Integer = _primitive.Integer.INSTANCE
Is = _primitive.Is.INSTANCE
Natural = _primitive.Natural.INSTANCE
NewLine = _primitive.NewLine.INSTANCE
NonVar = _primitive.NonVar.INSTANCE
NotUnifiableWith = _primitive.NotUnifiableWith.INSTANCE
Number = _primitive.Number.INSTANCE
NumberChars = _primitive.NumberChars.INSTANCE
NumberCodes = _primitive.NumberCodes.INSTANCE
Op = _primitive.Op.INSTANCE
Repeat = _primitive.Repeat.INSTANCE
Retract = _primitive.Retract.INSTANCE
RetractAll = _primitive.RetractAll.INSTANCE
Reverse = _primitive.Reverse.INSTANCE
SetDurable = _primitive.SetDurable.INSTANCE
SetEphemeral = _primitive.SetEphemeral.INSTANCE
SetFlag = _primitive.SetFlag.INSTANCE
SetOf = _primitive.SetOf.INSTANCE
SetPersistent = _primitive.SetPersistent.INSTANCE
Sleep = _primitive.Sleep.INSTANCE
SubAtom = _primitive.SubAtom.INSTANCE
TermGreaterThan = _primitive.TermGreaterThan.INSTANCE
TermGreaterThanOrEqualTo = _primitive.TermGreaterThanOrEqualTo.INSTANCE
TermIdentical = _primitive.TermIdentical.INSTANCE
TermLowerThan = _primitive.TermLowerThan.INSTANCE
TermLowerThanOrEqualTo = _primitive.TermLowerThanOrEqualTo.INSTANCE
TermNotIdentical = _primitive.TermNotIdentical.INSTANCE
TermNotSame = _primitive.TermNotSame.INSTANCE
TermSame = _primitive.TermSame.INSTANCE
UnifiesWith = _primitive.UnifiesWith.INSTANCE
Univ = _primitive.Univ.INSTANCE
Var = _primitive.Var.INSTANCE
Write = _primitive.Write.INSTANCE
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.stdlib.primitive.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/stdlib/primitive/__init__.py | __init__.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.channel as _channel
# noinspection PyUnresolvedReferences
import kotlin.jvm.functions as _kfunctions
from tuprolog.jvmutils import jmap, kfunction
from typing import Callable, Mapping
from functools import singledispatch
Channel = _channel.Channel
ChannelStore = _channel.ChannelStore
InputChannel = _channel.InputChannel
InputStore = _channel.InputStore
OutputChannel = _channel.OutputChannel
OutputStore = _channel.OutputStore
Listener = _kfunctions.Function1
def std_in() -> InputChannel:
return InputChannel.stdIn()
@singledispatch
def input_channel(generator: Callable, availability_checker: Callable = None) -> InputChannel:
if availability_checker is None:
return InputChannel.of(kfunction(0)(generator))
else:
return InputChannel.of(kfunction(0)(generator), kfunction(0)(availability_checker))
@input_channel.register
def input_channel_from_string(string: str) -> InputChannel:
return InputChannel.of(string)
def input_store(stdin: InputChannel = None, channels: Mapping[str, InputChannel] = None) -> InputStore:
if stdin is None and channels is None:
return InputStore.fromStandard()
elif channels is None:
return InputStore.fromStandard(stdin)
else:
cs = {InputStore.STDIN: stdin or std_in()}
for k, v in channels:
cs[k] = v
return InputStore.of(jmap(cs))
def std_out() -> OutputChannel:
return OutputChannel.stdOut()
def std_err() -> OutputChannel:
return OutputChannel.stdErr()
def warn() -> OutputChannel:
return OutputChannel.warn()
def output_channel(consumer: Callable) -> OutputChannel:
return OutputChannel.of(kfunction(1)(consumer))
def output_store(
stdout: OutputChannel = None,
stderr: OutputChannel = None,
warnings: OutputChannel = None,
channels: Mapping[str, OutputChannel] = None
) -> OutputStore:
if all((channel is None for channel in (stdout, stderr, warnings))):
return OutputStore.fromStandard()
elif channels is None:
return OutputStore.fromStandard(
stdout or std_out(),
stderr or std_err(),
warnings or warn()
)
else:
cs = {
OutputStore.STDOUT: stdout or std_out(),
OutputStore.STDERR: stderr or std_err()
}
for k, v in channels:
cs[k] = v
return OutputStore.of(jmap(cs), warnings or warn())
def listener(consumer: Callable) -> Listener:
return kfunction(1)(consumer)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.channel.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/channel/__init__.py | __init__.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.flags as _flags
from tuprolog.core import Term
from tuprolog.jvmutils import kpair, jmap, jarray, Pair
from typing import Iterable, Union, Mapping
DoubleQuotes = _flags.DoubleQuotes
FlagStore = _flags.FlagStore
LastCallOptimization = _flags.LastCallOptimization
MaxArity = _flags.MaxArity
NotableFlag = _flags.NotableFlag
Unknown = _flags.Unknown
Flag = Pair
EMPTY_FLAG_STORE: FlagStore = FlagStore.EMPTY
DEFAULT_FLAG_STORE: FlagStore = FlagStore.DEFAULT
DoubleQuotes: NotableFlag = DoubleQuotes.INSTANCE
LastCallOptimization: NotableFlag = LastCallOptimization.INSTANCE
MaxArity: NotableFlag = MaxArity.INSTANCE
Unknown: NotableFlag = Unknown.INSTANCE
def flag(first: Union[str, NotableFlag, Iterable], value: Term = None) -> Flag:
if isinstance(first, NotableFlag):
if value is None:
return first.toPair()
else:
return first.to(value)
elif isinstance(first, str):
if value is None:
raise ValueError("Argument value is None")
return Flag(first, value)
elif isinstance(first, Iterable) and value is None:
return kpair(first)
else:
raise ValueError("Argument first is not iterable nor str")
def flag_store(*flags: Union[NotableFlag, Flag, Iterable, FlagStore], **kwargs: Mapping[str, Term]):
normal_flags = []
notable_flags = []
other_stores = []
for f in flags:
if isinstance(f, NotableFlag):
notable_flags.append(f)
elif isinstance(f, Flag):
normal_flags.append(f)
elif isinstance(f, FlagStore):
other_stores.append(f)
else:
normal_flags.append(flag(f))
store1 = FlagStore.of(jarray(NotableFlag)@notable_flags)
store2 = FlagStore.of(jarray(Flag)@normal_flags)
store3 = FlagStore.of(jmap(kwargs))
store = store1.plus(store2).plus(store3)
for s in other_stores:
store = store.plus(s)
return store
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.flags.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/flags/__init__.py | __init__.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
from tuprolog.core import Term, Clause, Integer
from tuprolog.solve import ExecutionContext, Signature, Solution, current_time_instant, MAX_TIMEOUT
# from tuprolog.solve.sideffcts import SideEffect
from tuprolog.pyutils import iterable_or_varargs
from tuprolog.jvmutils import jlist
from typing import List, Iterable, Callable
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.primitive as _primitive
Primitive = _primitive.Primitive
Solve = _primitive.Solve
PrimitiveWrapper = _primitive.PrimitiveWrapper
SolveRequest = Solve.Request
SolveResponse = Solve.Request
@jpype.JImplements(Primitive)
class AbstractPrimitive(object):
@jpype.JOverride
def solve(self, request: SolveRequest) -> Iterable[SolveResponse]:
raise NotImplementedError()
def primitive(callable: Callable[[SolveResponse], Iterable[SolveResponse]]) -> Primitive:
class CallableToPrimitiveAdapter(AbstractPrimitive):
def solve(self, request: SolveRequest) -> Iterable[SolveResponse]:
return callable(request)
return CallableToPrimitiveAdapter()
def solve_request(
signature: Signature,
arguments: List[Term],
context: ExecutionContext,
issuing_instant: int = current_time_instant(),
max_duration: int = MAX_TIMEOUT
) -> SolveRequest:
return SolveRequest(signature, arguments, context, issuing_instant, max_duration)
def solve_response(solution: Solution, *side_effects) -> SolveResponse:
return iterable_or_varargs(side_effects, lambda ses: SolveResponse(solution, None, jlist(ses)))
def check_term_is_recursively_callable(request: SolveRequest, term: Term):
return PrimitiveWrapper.checkTermIsRecursivelyCallable(request, term)
def ensuring_all_arguments_are_instantiated(request: SolveRequest) -> SolveRequest:
return PrimitiveWrapper.ensuringAllArgumentsAreInstantiated(request)
def ensuring_procedure_has_permission(request: SolveRequest, signature: Signature, operation) -> SolveRequest:
return PrimitiveWrapper.ensuringProcedureHasPermission(request, signature, operation)
def ensuring_clause_procedure_has_permission(request: SolveRequest, clause: Clause, operation) -> SolveRequest:
return PrimitiveWrapper.ensuringClauseProcedureHasPermission(request, clause, operation)
def ensuring_argument_is_well_formed_indicator(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsWellFormedIndicator(request, index)
def not_implemented(request: SolveRequest, message: str) -> SolveResponse:
return PrimitiveWrapper.notImplemented(request, message)
def not_supported(request: SolveRequest, message: str) -> SolveResponse:
return PrimitiveWrapper.notSupported(request, message)
def ensuring_argument_is_well_formed_clause(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsWellFormedClause(request, index)
def ensuring_argument_is_instantiated(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsInstantiated(request, index)
def ensuring_argument_is_numeric(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsNumeric(request, index)
def ensuring_argument_is_struct(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsStruct(request, index)
def ensuring_argument_is_callable(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsCallable(request, index)
def ensuring_argument_is_variable(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsVariable(request, index)
def ensuring_argument_is_compound(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsCompound(request, index)
def ensuring_argument_is_atom(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsCompound(request, index)
def ensuring_argument_is_constant(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsConstant(request, index)
def ensuring_argument_is_ground(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsGround(request, index)
def ensuring_argument_is_char(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsChar(request, index)
def ensuring_argument_is_specifier(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsSpecifier(request, index)
def ensuring_argument_is_integer(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsInteger(request, index)
def ensuring_argument_is_list(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsList(request, index)
def ensuring_argument_is_arity(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsArity(request, index)
def ensuring_argument_is_non_negative_integer(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsNonNegativeInteger(request, index)
def is_character_code(integer: Integer) -> bool:
return PrimitiveWrapper.isCharacterCode(integer)
def ensuring_term_is_char_code(request: SolveRequest, term: Term) -> SolveRequest:
return PrimitiveWrapper.ensuringTermIsCharCode(request, term)
def ensuring_term_is_well_formed_list(request: SolveRequest, term: Term) -> SolveRequest:
return PrimitiveWrapper.ensuringTermIsWellFormedList(request, term)
def ensuring_argument_is_char_code(request: SolveRequest, index: int) -> SolveRequest:
return PrimitiveWrapper.ensuringArgumentIsCharCode(request, index)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.primitive.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/primitive/__init__.py | __init__.py |
from typing import Iterable, Union
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.exception.error as errors
from tuprolog.core import Term
from tuprolog.solve import ExecutionContext, Signature
DomainError = errors.DomainError
Domain = DomainError.Expected
DOMAIN_wATOM_PROPERTY = Domain.ATOM_PROPERTY
DOMAIN_BUFFERING_MODE = Domain.BUFFERING_MODE
DOMAIN_CHARACTER_CODE_LIST = Domain.CHARACTER_CODE_LIST
DOMAIN_CLOSE_OPTION = Domain.CLOSE_OPTION
DOMAIN_DATE_TIME = Domain.DATE_TIME
DOMAIN_EOF_ACTION = Domain.EOF_ACTION
DOMAIN_FLAG_VALUE = Domain.FLAG_VALUE
DOMAIN_FORMAT_CONTROL_SEQUENCE = Domain.FORMAT_CONTROL_SEQUENCE
DOMAIN_IO_MODE = Domain.IO_MODE
DOMAIN_WELL_FORMED_LIST = Domain.WELL_FORMED_LIST
DOMAIN_NON_EMPTY_LIST = Domain.NON_EMPTY_LIST
DOMAIN_NOT_LESS_THAN_ZERO = Domain.NOT_LESS_THAN_ZERO
DOMAIN_OPERATOR_PRIORITY = Domain.OPERATOR_PRIORITY
DOMAIN_OPERATOR_SPECIFIER = Domain.OPERATOR_SPECIFIER
DOMAIN_ORDER = Domain.ORDER
DOMAIN_OS_FILE_PERMISSION = Domain.OS_FILE_PERMISSION
DOMAIN_OS_FILE_PROPERTY = Domain.OS_FILE_PROPERTY
DOMAIN_OS_PATH = Domain.OS_PATH
DOMAIN_PREDICATE_PROPERTY = Domain.PREDICATE_PROPERTY
DOMAIN_FLAG = Domain.FLAG
DOMAIN_READ_OPTION = Domain.READ_OPTION
DOMAIN_SELECTABLE_ITEM = Domain.SELECTABLE_ITEM
DOMAIN_SOCKET_ADDRESS = Domain.SOCKET_ADDRESS
DOMAIN_SOCKET_DOMAIN = Domain.SOCKET_DOMAIN
DOMAIN_SOURCE_SINK = Domain.SOURCE_SINK
DOMAIN_STREAM = Domain.STREAM
DOMAIN_STREAM_OPTION = Domain.STREAM_OPTION
DOMAIN_STREAM_OR_ALIAS = Domain.STREAM_OR_ALIAS
DOMAIN_STREAM_POSITION = Domain.STREAM_POSITION
DOMAIN_STREAM_PROPERTY = Domain.STREAM_PROPERTY
DOMAIN_STREAM_SEEK_METHOD = Domain.STREAM_SEEK_METHOD
DOMAIN_STREAM_TYPE = Domain.STREAM_TYPE
DOMAIN_TERM_STREAM_OR_ALIAS = Domain.TERM_STREAM_OR_ALIAS
DOMAIN_VAR_BINDING_OPTION = Domain.VAR_BINDING_OPTION
DOMAIN_WRITE_OPTION = Domain.WRITE_OPTION
DOMAIN_CLAUSE = Domain.CLAUSE
DOMAIN_RULE = Domain.RULE
DOMAIN_FACT = Domain.FACT
DIRECTIVE = Domain.DIRECTIVE
def domain_error_for_flag_values(
context: ExecutionContext,
procedure: Signature,
flag_values: Iterable[Term],
actual: Term,
index: int = None
) -> DomainError:
return DomainError.forFlagValues(context, procedure, flag_values, actual, index)
def domain_error_for_argument(
context: ExecutionContext,
procedure: Signature,
expected: Domain,
actual: Term,
index: int = None
) -> DomainError:
return DomainError.forArgument(context, procedure, expected, actual, index)
def domain_error_for_term(
context: ExecutionContext,
expected: Domain,
actual_value: Term,
) -> DomainError:
return DomainError.forTerm(context, expected, actual_value)
def domain_error_for_goal(
context: ExecutionContext,
procedure: Signature,
expected: Domain,
actual: Term,
) -> DomainError:
return DomainError.forGoal(context, procedure, expected, actual)
def domain(name: Union[str, Term]) -> Domain:
if isinstance(name, str):
return Domain.of(name)
else:
return Domain.fromTerm(name)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.exception.error.DomainError.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/exception/error/domain/__init__.py | __init__.py |
from typing import Union
# noinspection PyUnresolvedReferences
import jpype.imports
from tuprolog import logger
from tuprolog.core import Term
from tuprolog.solve import ExecutionContext, Signature
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.exception.error as errors
PermissionError = errors.PermissionError
Operation = PermissionError.Operation
Permission = PermissionError.Permission
OPERATION_ACCESS = Operation.ACCESS
OPERATION_ADD_ALIAS = Operation.ADD_ALIAS
OPERATION_CLOSE = Operation.CLOSE
OPERATION_CREATE = Operation.CREATE
OPERATION_INPUT = Operation.INPUT
OPERATION_INVOKE = Operation.INVOKE
OPERATION_MODIFY = Operation.MODIFY
OPERATION_OPEN = Operation.OPEN
OPERATION_OUTPUT = Operation.OUTPUT
OPERATION_REPOSITION = Operation.REPOSITION
PERMISSION_BINARY_STREAM = Permission.BINARY_STREAM
PERMISSION_FLAG = Permission.FLAG
PERMISSION_OPERATOR = Permission.OPERATOR
PERMISSION_PAST_END_OF_STREAM = Permission.PAST_END_OF_STREAM
PERMISSION_PRIVATE_PROCEDURE = Permission.PRIVATE_PROCEDURE
PERMISSION_SOURCE_SINK = Permission.SOURCE_SINK
PERMISSION_STATIC_PROCEDURE = Permission.STATIC_PROCEDURE
PERMISSION_OOP_METHOD = Permission.OOP_METHOD
PERMISSION_STREAM = Permission.STREAM
PERMISSION_TEXT_STREAM = Permission.TEXT_STREAM
def permission_error(
context: ExecutionContext,
procedure: Signature,
operation: Operation,
permission: Permission,
culprit: Term
) -> PermissionError:
return PermissionError.of(context, procedure, operation, permission, culprit)
def operation(name: Union[str, Term]) -> Operation:
if isinstance(name, str):
return Operation.of(name)
else:
return Operation.fromTerm(name)
def permission(name: Union[str, Term]) -> Permission:
if isinstance(name, str):
return Permission.of(name)
else:
return Permission.fromTerm(name)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.exception.error.PermissionError.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/exception/error/permission/__init__.py | __init__.py |
from typing import Union
# noinspection PyUnresolvedReferences
import jpype.imports
from tuprolog import logger
from tuprolog.core import Term
from tuprolog.solve import ExecutionContext, Signature
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.exception.error as errors
TypeError = errors.TypeError
Type = TypeError.Expected
TYPE_ATOM = Type.ATOM
TYPE_ATOMIC = Type.ATOMIC
TYPE_BOOLEAN = Type.BOOLEAN
TYPE_BYTE = Type.BYTE
TYPE_CALLABLE = Type.CALLABLE
TYPE_CHARACTER = Type.CHARACTER
TYPE_COMPOUND = Type.COMPOUND
TYPE_DEALIASING_EXPRESSION = Type.DEALIASING_EXPRESSION
TYPE_EVALUABLE = Type.EVALUABLE
TYPE_FLOAT = Type.FLOAT
TYPE_INTEGER = Type.INTEGER
TYPE_IN_CHARACTER = Type.IN_CHARACTER
TYPE_LIST = Type.LIST
TYPE_NUMBER = Type.NUMBER
TYPE_OBJECT_REFERENCE = Type.OBJECT_REFERENCE
TYPE_PAIR = Type.PAIR
TYPE_PREDICATE_INDICATOR = Type.PREDICATE_INDICATOR
TYPE_REFERENCE = Type.REFERENCE
TYPE_TYPE_REFERENCE = Type.TYPE_REFERENCE
TYPE_URL = Type.URL
TYPE_VARIABLE = Type.VARIABLE
def type_error_for_flag_values(
context: ExecutionContext,
procedure: Signature,
expected: Type,
actual: Term,
message: str
) -> TypeError:
return TypeError.of(context, procedure, expected, actual, message)
def type_error_for_argument_list(
context: ExecutionContext,
procedure: Signature,
expected: Type,
actual: Term,
index: int = None
) -> TypeError:
return TypeError.forArgumentList(context, procedure, expected, actual, index)
def type_error_for_argument(
context: ExecutionContext,
procedure: Signature,
expected: Type,
actual: Term,
index: int = None
) -> TypeError:
return TypeError.forArgument(context, procedure, expected, actual, index)
def type_error_for_term(
context: ExecutionContext,
expected: Type,
actual_value: Term,
) -> TypeError:
return TypeError.forTerm(context, expected, actual_value)
def type_error_for_goal(
context: ExecutionContext,
procedure: Signature,
expected: Type,
actual: Term,
) -> TypeError:
return TypeError.forGoal(context, procedure, expected, actual)
def type(name: Union[str, Term]) -> Type:
if isinstance(name, str):
return TypeError.valueOf(name)
else:
return TypeError.fromTerm(name)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.exception.error.TypeError.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/exception/error/type/__init__.py | __init__.py |
from functools import reduce
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
from tuprolog.core.operators import OperatorSet, operator_set
from tuprolog.theory import Theory, theory
from tuprolog.solve import Signature
from tuprolog.solve.primitive import Primitive
from tuprolog.solve.function import LogicFunction
from tuprolog.jvmutils import jiterable
from typing import Union, Mapping, Iterable
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.solve.library as _library
Library = _library.Library
Libraries = _library.Libraries
LibraryGroup = _library.LibraryGroup
AliasedLibrary = _library.AliasedLibrary
def library(
alias: str = None,
primitives: Mapping[Signature, Primitive] = dict(),
theory: Theory = theory(),
operators: OperatorSet = operator_set(),
functions: Mapping[Signature, LogicFunction] = dict(),
) -> Union[Library, AliasedLibrary]:
if alias is None:
return Library.unaliased(primitives, theory, operators, functions)
else:
return Library.aliased(alias, primitives, theory, operators, functions)
def aliased(alias: str, library: Library) -> AliasedLibrary:
return Library.of(alias, library)
def libraries(
*libs: Union[Libraries, AliasedLibrary, Iterable[Union[Libraries, AliasedLibrary]]],
**kwargs: Library
) -> Libraries:
all_libraries = []
aliased_libs = []
queue = list(libs)
while len(queue) > 0:
current = queue.pop()
if isinstance(current, Libraries):
all_libraries.append(current)
elif isinstance(current, AliasedLibrary):
aliased_libs.append(current)
else:
queue.extend(current)
for alias in kwargs:
aliased_libs.append(aliased(alias, kwargs[alias]))
first = Libraries.of(jiterable(aliased_libs))
return reduce(lambda a, b: a.plus(b), all_libraries, first)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.library.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/library/__init__.py | __init__.py |
from functools import reduce
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
from it.unibo.tuprolog.solve.sideffects import SideEffect
# noinspection PyUnresolvedReferences
from it.unibo.tuprolog.solve.sideffects import SideEffectFactory
# noinspection PyUnresolvedReferences
from it.unibo.tuprolog.solve.sideffects import SideEffectsBuilder
# noinspection PyUnresolvedReferences
from tuprolog.core import Clause, Term
# noinspection PyUnresolvedReferences
from tuprolog.core.operators import Operator, OperatorSet
# noinspection PyUnresolvedReferences
from tuprolog.solve.library import Library, AliasedLibrary, Libraries, libraries as new_libraries
# noinspection PyUnresolvedReferences
from tuprolog.solve.channel import InputChannel, OutputChannel
from tuprolog.pyutils import iterable_or_varargs, dict_or_keyword_args
from tuprolog.jvmutils import jlist, jmap
from typing import Mapping, Union, Iterable, Any
def _forward_iterable_or_varargs(callable, args, *callable_args):
return iterable_or_varargs(args, lambda xs: callable(jlist(xs), *callable_args))
def _forward_dict_or_keywords(callable, dict, kwargs, *callable_args):
return dict_or_keyword_args(dict, kwargs, lambda ds: callable(jmap(ds), *callable_args))
def reset_static_kb(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.ResetStaticKb:
return _forward_iterable_or_varargs(SideEffect.ResetStaticKb, clauses)
def add_static_clauses(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.AddStaticClauses:
return _forward_iterable_or_varargs(SideEffect.AddStaticClauses, clauses)
def remove_static_clauses(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.RemoveStaticClauses:
return _forward_iterable_or_varargs(SideEffect.RemoveStaticClauses, clauses)
def reset_dynamic_kb(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.ResetDynamicKb:
return _forward_iterable_or_varargs(SideEffect.ResetDynamicKb, clauses)
def add_dynamic_clauses(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.AddDynamicClauses:
return _forward_iterable_or_varargs(SideEffect.AddDynamicClauses, clauses)
def remove_dynamic_clauses(*clauses: Union[Clause, Iterable[Clause]]) -> SideEffect.RemoveDynamicClauses:
return _forward_iterable_or_varargs(SideEffect.RemoveDynamicClauses, clauses)
def set_flags(flags: Mapping[str, Term] = {}, **kwargs: Term) -> SideEffect.SetFlags:
return _forward_dict_or_keywords(SideEffect.SetFlags, flags, kwargs)
def reset_flags(flags: Mapping[str, Term] = {}, **kwargs: Term) -> SideEffect.ResetFlags:
return _forward_dict_or_keywords(SideEffect.ResetFlags, flags, kwargs)
def clear_flags(*flag_names: str) -> SideEffect.ClearFlags:
return _forward_iterable_or_varargs(SideEffect.ClearFlags, flag_names)
def load_library(alias: str, library: Library) -> SideEffect.LoadLibrary:
return SideEffect.LoadLibrary(alias, library)
def unload_libraries(*aliases: str) -> SideEffect.UnloadLibraries:
return _forward_iterable_or_varargs(SideEffect.UnloadLibraries, aliases)
def update_library(alias: str, library: Library) -> SideEffect.UpdateLibrary:
return SideEffect.UpdateLibrary(alias, library)
def add_libraries(*libraries: Union[Libraries, AliasedLibrary]) -> SideEffect.AddLibraries:
return SideEffect.AddLibraries(new_libraries(libraries))
def reset_libraries(*libraries: Union[Libraries, AliasedLibrary]) -> SideEffect.ResetLibraries:
return SideEffect.ResetLibraries(new_libraries(libraries))
def set_operators(*operators: Union[Operator, Iterable[Operator]]) -> SideEffect.SetOperators:
return _forward_iterable_or_varargs(SideEffect.SetOperators, operators)
def reset_operators(*operators: Union[Operator, Iterable[Operator]]) -> SideEffect.ResetOperators:
return _forward_iterable_or_varargs(SideEffect.ResetOperators, operators)
def remove_operators(*operators: Union[Operator, Iterable[Operator]]) -> SideEffect.RemoveOperators:
return _forward_iterable_or_varargs(SideEffect.RemoveOperators, operators)
def open_input_channels(
channels: Mapping[str, InputChannel] = {},
**kwargs: InputChannel
) -> SideEffect.OpenInputChannels:
return _forward_dict_or_keywords(SideEffect.OpenInputChannels, channels, kwargs)
def reset_input_channels(
channels: Mapping[str, InputChannel] = {},
**kwargs: InputChannel
) -> SideEffect.ResetInputChannels:
return _forward_dict_or_keywords(SideEffect.ResetInputChannels, channels, kwargs)
def close_input_channels(*names: Union[str, Iterable[str]]) -> SideEffect.CloseInputChannels:
return _forward_iterable_or_varargs(SideEffect.CloseInputChannels, names)
def open_output_channels(
channels: Mapping[str, OutputChannel] = {},
**kwargs: OutputChannel
) -> SideEffect.OpenOutputChannels:
return _forward_dict_or_keywords(SideEffect.OpenOutputChannels, channels, kwargs)
def reset_output_channels(
channels: Mapping[str, OutputChannel] = {},
**kwargs: OutputChannel
) -> SideEffect.ResetOutputChannels:
return _forward_dict_or_keywords(SideEffect.ResetOutputChannels, channels, kwargs)
def close_output_channels(*names: Union[str, Iterable[str]]) -> SideEffect.CloseOutputChannels:
return _forward_iterable_or_varargs(SideEffect.CloseOutputChannels, names)
def set_persistent_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetPersistentData:
return _forward_dict_or_keywords(SideEffect.SetPersistentData, data, kwargs, False)
def reset_persistent_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetPersistentData:
return _forward_dict_or_keywords(SideEffect.SetPersistentData, data, kwargs, True)
def set_durable_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetDurableData:
return _forward_dict_or_keywords(SideEffect.SetDurableData, data, kwargs, False)
def reset_durable_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetDurableData:
return _forward_dict_or_keywords(SideEffect.SetDurableData, data, kwargs, True)
def set_ephemeral_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetEphemeralData:
return _forward_dict_or_keywords(SideEffect.SetEphemeralData, data, kwargs, False)
def reset_ephemeral_data(
data: Mapping[str, Any] = {},
**kwargs: Any
) -> SideEffect.SetEphemeralData:
return _forward_dict_or_keywords(SideEffect.SetEphemeralData, data, kwargs, True)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.solve.sideffects.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/solve/sideffcts/__init__.py | __init__.py |
from tuprolog import logger
import jpype
from tuprolog.core import indicator as new_indicator
from tuprolog.jvmutils import jiterable, protect_iterable
from tuprolog.pyutils import iterable_or_varargs
from typing import Sized
@jpype.JImplementationFor("it.unibo.tuprolog.theory.Theory")
class _KtTheory:
def __jclass_init__(cls):
Sized.register(cls)
@property
def is_mutable(self):
return self.isMutable()
def to_mutable_theory(self):
return self.toMutableTheory()
def to_immutable_theory(self):
return self.toImmutableTheory()
@jpype.JOverride
def getClauses(self):
return protect_iterable(self.getClauses_())
@property
def clauses(self):
return self.getClauses()
@jpype.JOverride
def getRules(self):
return protect_iterable(self.getRules_())
@property
def rules(self):
return self.getRules()
@jpype.JOverride
def getDirectives(self):
return protect_iterable(self.getDirectives_())
@property
def directives(self):
return self.getDirectives()
def __len__(self):
return self.getSize()
def __add__(self, other):
return self.plus(other)
def __contains__(self, item):
return self.contains(item)
def __getitem__(self, item):
return self.get(item)
def _assert(self, method, clause, *clauses):
if len(clauses) == 0:
return method(clause)
return iterable_or_varargs((clause,) + clauses, lambda cs: method(jiterable(cs)))
def assert_a(self, clause, *clauses):
self._assert(self.assertA, clause, *clauses)
def assert_z(self, clause, *clauses):
self._assert(self.assertZ, clause, *clauses)
@jpype.JOverride
def retract(self, clause, *clauses):
if len(clauses) == 0:
return self.retract_(clause)
return iterable_or_varargs((clause,) + clauses, lambda cs: self.retract_(jiterable(cs)))
def retract_all(self, clause):
return self.retractAll(clause)
@jpype.JOverride
def abolish(self, name, arity=None, indicator=None):
if name is not None:
if arity is not None:
return self.abolish_(new_indicator(name, arity))
else:
return self.abolish_(name)
elif indicator is not None:
return self.abolish_(indicator)
raise ValueError("You should provide at least either a name-arity couple or an indicator")
@jpype.JOverride
def equals(self, other, use_var_complete_name=True):
return self.equals_(other, use_var_complete_name)
def __eq__(self, other):
return self.equals(other, use_var_complete_name=True)
def to_string(self, as_prolog_text=False):
return self.toString(as_prolog_text)
@jpype.JImplementationFor("it.unibo.tuprolog.theory.RetractResult")
class _KtRetractResult:
def __jclass_init__(cls):
pass
@property
def is_success(self):
return self.isSuccess()
@property
def is_failure(self):
return self.isFailure()
@property
def theory(self):
return self.getTheory()
@property
def clauses(self):
return self.getClauses()
@property
def first_clause(self):
return self.getFirstClause()
logger.debug("Configure Kotlin adapters for types in it.unibo.tuprolog.theory.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/theory/_ktadapt.py | _ktadapt.py |
from decimal import Decimal
from tuprolog import logger
import jpype
from ._ktmath import big_integer, big_decimal, BigInteger, BigDecimal
from tuprolog.utils import *
from typing import Sized, Callable
from tuprolog.jvmutils import jiterable
from tuprolog.pyutils import iterable_or_varargs
from tuprolog.jvmutils import kfunction
from ._ktmath import *
@jpype.JImplementationFor("it.unibo.tuprolog.core.Term")
class _KtTerm:
def __jclass_init__(cls):
pass
def __getitem__(self, item, *items):
return self.get(item, *items)
@property
def variables(self):
return self.getVariables()
def structurally_equals(self, other):
return self.structurallyEquals(other)
@jpype.JOverride()
def equals(self, other, use_var_complete_name: bool = True):
return self.equals_(other, use_var_complete_name)
@property
def is_var(self):
return self.isVar()
@property
def is_ground(self):
return self.isGround()
@property
def is_struct(self):
return self.isStruct()
@property
def is_truth(self):
return self.isTruth()
@property
def is_recursive(self):
return self.isRecursive()
@property
def is_atom(self):
return self.isAtom()
@property
def is_constant(self):
return self.isConstant()
@property
def is_number(self):
return self.isNumber()
@property
def is_integer(self):
return self.isInteger()
@property
def is_real(self):
return self.isReal()
@property
def is_list(self):
return self.isList()
@property
def is_tuple(self):
return self.isTuple()
@property
def is_block(self):
return self.isBlock()
@property
def is_clause(self):
return self.isClause()
@property
def is_rule(self):
return self.isRule()
@property
def is_fact(self):
return self.isFact()
@property
def is_directive(self):
return self.isDirective()
@property
def is_cons(self):
return self.isCons()
@property
def is_empty_list(self):
return self.isEmptyList()
@property
def is_true(self):
return self.isTrue()
@property
def is_fail(self):
return self.isFail()
@property
def is_indicator(self):
return self.isIndicator()
def fresh_copy(self, scope=None):
if scope is None:
return self.freshCopy()
else:
return self.freshCopy(scope)
@jpype.JImplementationFor("it.unibo.tuprolog.core.Struct")
class _KtStruct:
def __jclass_init__(cls):
pass
@property
def functor(self):
return self.getFunctor()
@property
def args(self):
return self.getArgs()
@property
def argsSequence(self):
return self.getArgsSequence()
@property
def arity(self):
return self.getArity()
@property
def is_functor_well_formed(self):
return self.isFunctorWellFormed()
@property
def indicator(self):
return self.getIndicator()
def get_arg_at(self, index):
return self.getArgAt(index)
def add_last(self, argument):
return self.addLast(argument)
def add_first(self, argument):
return self.addFirst(argument)
def insert_at(self, index, argument):
return self.addFirst(index, argument)
def set_functor(self, functor):
return self.setFunctor(functor)
def set_args(self, *args):
return iterable_or_varargs(args, lambda xs: self.setArgs(jiterable(args)))
@jpype.JImplementationFor("it.unibo.tuprolog.core.Var")
class _KtVar:
def __jclass_init__(cls):
pass
@property
def is_anonymous(self):
return self.isAnonymous()
@property
def name(self):
return self.getName()
@property
def id(self):
return self.getId()
@property
def complete_name(self):
return self.getCompleteName()
@property
def is_name_well_formed(self):
return self.isNameWellFormed()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Constant")
class _KtConstant:
def __jclass_init__(cls):
pass
@property
def value(self):
return self.getValue()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Numeric")
class _KtNumeric:
def __jclass_init__(cls):
pass
@property
def int_value(self):
return python_integer(self.getIntValue())
@property
def decimal_value(self):
return python_decimal(self.getDecimalValue())
def to_int(self):
return self.int_value
def to_float(self):
return float(self.decimal_value)
@jpype.JImplementationFor("it.unibo.tuprolog.core.Integer")
class _KtInteger:
def __jclass_init__(cls):
pass
@property
def value(self):
return self.int_value
@jpype.JImplementationFor("it.unibo.tuprolog.core.Real")
class _KtReal:
def __jclass_init__(cls):
pass
@property
def value(self):
return self.decimal_value
@jpype.JImplementationFor("it.unibo.tuprolog.core.Recursive")
class _KtRecursive:
def __jclass_init__(cls):
Sized.register(cls)
@property
def lazily_unfolded(self):
return self.getUnfoldedSequence()
@property
def unfolded(self):
return self.getUnfoldedList()
@property
def __len__(self):
return self.getSize()
def to_iterable(self):
return self.toSequence()
def to_list(self):
return self.toList()
def to_array(self):
return self.toArray()
@jpype.JImplementationFor("it.unibo.tuprolog.core.List")
class _KtList:
def __jclass_init__(cls):
pass
@property
def is_well_formed(self):
return self.isWellFormed()
@property
def last(self):
return self.getLast()
def estimated_length(self):
return self.getEstimatedLength()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Cons")
class _KtCons:
def __jclass_init__(cls):
pass
@property
def head(self):
return self.getHead()
@property
def tail(self):
return self.getTail()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Tuple")
class _KtTuple:
def __jclass_init__(cls):
pass
@property
def left(self):
return self.getLeft()
@property
def right(self):
return self.getRight()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Clause")
class _KtClause:
def __jclass_init__(cls):
pass
@property
def head(self):
return self.getHead()
@property
def body(self):
return self.getBody()
@property
def is_well_formed(self):
return self.isWellFormed()
@property
def body_items(self):
return self.getBodyItems()
@property
def body_size(self):
return self.getBodySize()
def get_body_item(self, index):
return self.getBodyItem(index)
def set_head(self, head):
return self.setHead(head)
def set_body(self, term):
return self.setBody(term)
def set_head_functor(self, functor):
return self.setHeadFunctor(functor)
def set_head_args(self, *args):
return iterable_or_varargs(args, lambda xs: self.setHeadArgs(jiterable(args)))
def insert_head_arg(self, index, argument):
return self.setHeadArg(index, argument)
def add_first_head_arg(self, argument):
return self.addFirstHeadArg(argument)
def add_last_head_arg(self, argument):
return self.addLastHeadArg(argument)
def append_head_arg(self, argument):
return self.appendHeadArg(argument)
def set_body_items(self, *args):
return iterable_or_varargs(args, lambda xs: self.setBodyItems(jiterable(args)))
def insert_body_item(self, index, item):
return self.insertBodyItem(index, item)
def add_first_body_item(self, item):
return self.addFirstBodyItem(item)
def add_last_body_item(self, item):
return self.addLastBodyItem(item)
def append_body_item(self, item):
return self.appendBodyItem(item)
@jpype.JImplementationFor("it.unibo.tuprolog.core.Rule")
class _KtRule:
def __jclass_init__(cls):
pass
@property
def head_args(self):
return self.getHeadArgs()
@property
def head_arity(self):
return self.getHeadArity()
def get_head_arg(self, index):
return self.getHeadArg(index)
@jpype.JImplementationFor("it.unibo.tuprolog.core.TermConvertible")
class _KtTermConvertible:
def __jclass_init__(cls):
pass
def to_term(self):
return self.toTerm()
@jpype.JImplementationFor("it.unibo.tuprolog.core.Substitution")
class _KtSubstitution:
def __jclass_init__(cls):
pass
@property
def is_success(self):
return self.isSuccess()
@property
def is_failed(self):
return self.isFailed()
def apply_to(self, term):
return self.applyTo(term)
def get_original(self, variable):
return self.getOriginal(variable)
def get_by_name(self, name):
return self.getByName(name)
def __add__(self, other):
return self.plus(other)
def __sub__(self, other):
return self.minus(other)
@jpype.JOverride
def filter(self, filter):
if isinstance(filter, Callable):
return self.filter_(kfunction(1)(filter))
else:
return self.filter_(filter)
@jpype.JImplementationFor("it.unibo.tuprolog.core.Scope")
class _KtScope:
def __jclass_init__(cls):
pass
def __contains__(self, item):
return self.contains(item)
def __getitem__(self, item):
return self.get(item)
@property
def variables(self):
return self.getVariables()
@property
def fail(self):
return self.getFail()
@property
def empty_list(self):
return self.getEmptyList()
@property
def empty_block(self):
return self.getEmptyBlock()
def atom(self, string):
return self.atomOf(string)
def block(self, *terms):
return iterable_or_varargs(terms, lambda ts: self.blockOf(jiterable(ts)))
def clause(self, head=None, *body):
return iterable_or_varargs(body, lambda bs: self.clauseOf(head, jiterable(bs)))
def cons(self, head, tail=None):
if tail is None:
return self.listOf(head)
else:
return self.consOf(head, tail)
def directive(self, *goals):
return iterable_or_varargs(goals, lambda gs: self.directiveOf(jiterable(gs)))
def fact(self, head):
return self.factOf(head)
def indicator(self, name, arity):
return self.indicatorOf(name, arity)
def integer(self, value):
return self.intOf(big_integer(value))
def real(self, value):
return self.intOf(big_integer(value))
def numeric(self, value):
if isinstance(value, str):
return self.numOf(value)
if isinstance(value, int) or isinstance(value, BigInteger):
return self.intOf(value)
return self.realOf(value)
def rule(self, head, *body):
return iterable_or_varargs(body, lambda bs: self.ruleOf(head, jiterable(bs)))
def struct(self, functor, *args):
return iterable_or_varargs(args, lambda xs: self.structOf(functor, jiterable(xs)))
def truth(self, value):
return self.truthOf(value)
def var(self, name):
return self.varOf(name)
def list(self, *items):
return iterable_or_varargs(items, lambda xs: self.listOf(jiterable(xs)))
def list_from(self, items, last=None):
return self.listFrom(jiterable(items), last)
def tuple(self, first, second, *others):
return iterable_or_varargs(others, lambda os: self.tupleOf(jiterable([first, second] + list(os))))
@property
def anonymous(self):
return self.getAnonymous()
@property
def whatever(self):
return self.getWhatever()
logger.debug("Configure Kotlin adapters for types in it.unibo.tuprolog.core.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/_ktadapt.py | _ktadapt.py |
from typing import Union
import decimal
import jpype.imports
# noinspection PyUnresolvedReferences
import org.gciatto.kt.math as _ktmath
# noinspection PyUnresolvedReferences
import java.lang as _java_lang
from math import ceil
from tuprolog.pyutils import and_then
BigInteger = _ktmath.BigInteger
BigDecimal = _ktmath.BigDecimal
MathContext = _ktmath.MathContext
RoundingMode = _ktmath.RoundingMode
_MAX_LONG = _java_lang.Long.MAX_VALUE
_MIN_LONG = _java_lang.Long.MIN_VALUE
BIG_INTEGER_MAX_LONG = BigInteger.of(_MAX_LONG)
BIG_INTEGER_MIN_LONG = BigInteger.of(_MIN_LONG)
BIG_INTEGER_ZERO = BigInteger.ZERO
BIG_INTEGER_TEN = BigInteger.TEN
BIG_INTEGER_ONE = BigInteger.ONE
BIG_INTEGER_NEGATIVE_ONE = BigInteger.NEGATIVE_ONE
BIG_INTEGER_TWO = BigInteger.TWO
BIG_DECIMAL_ZERO = BigDecimal.ZERO
BIG_DECIMAL_ONE = BigDecimal.ONE
BIG_DECIMAL_ONE_HALF = BigDecimal.ONE_HALF
BIG_DECIMAL_ONE_TENTH = BigDecimal.ONE_TENTH
BIG_DECIMAL_E = BigDecimal.E
BIG_DECIMAL_PI = BigDecimal.PI
def _int_to_bytes(n: int) -> bytes:
try:
size = n.bit_length() // 8 + 1
return n.to_bytes(size, 'big', signed=True)
except OverflowError as e:
e.args = ["%s: %d, whose size is %d" % (e.args[0], n, size)]
raise e
def big_integer(value: Union[str, int], radix: int = None) -> BigInteger:
if radix is not None:
assert isinstance(value, str)
return BigInteger.of(value, radix)
if isinstance(value, str):
return BigInteger.of(jpype.JString @ value)
assert isinstance(value, int)
bs = _int_to_bytes(value)
return BigInteger(jpype.JArray(jpype.JByte) @ bs, 0, len(bs))
def python_integer(value: BigInteger) -> int:
return int.from_bytes(value.toByteArray(), byteorder='big', signed=True)
_python_rounding_modes = {decimal.ROUND_DOWN, decimal.ROUND_HALF_UP, decimal.ROUND_HALF_EVEN, decimal.ROUND_CEILING,
decimal.ROUND_FLOOR, decimal.ROUND_UP, decimal.ROUND_HALF_DOWN, decimal.ROUND_05UP}
def jvm_rounding_mode(mode):
if mode == decimal.ROUND_DOWN:
return RoundingMode.DOWN
elif mode == decimal.ROUND_UP:
return RoundingMode.UP
elif mode == decimal.ROUND_FLOOR:
return RoundingMode.FLOOR
elif mode == decimal.ROUND_CEILING:
return RoundingMode.CEILING
elif mode == decimal.ROUND_HALF_UP:
return RoundingMode.HALF_UP
elif mode == decimal.ROUND_HALF_EVEN:
return RoundingMode.HALF_EVEN
elif mode == decimal.ROUND_HALF_DOWN:
return RoundingMode.HALF_DOWN
elif mode == decimal.ROUND_05UP:
raise ValueError(f"Rounding mode {decimal.ROUND_05UP} has no Java correspondence")
else:
raise ValueError(f"Not a rounding mode {mode}")
@and_then(lambda bd: bd.stripTrailingZeros())
def big_decimal(value: Union[str, int, float, decimal.Decimal], precision=0,
rounding=RoundingMode.HALF_UP) -> BigDecimal:
if precision is None:
precision = decimal.getcontext().prec
assert isinstance(precision, int)
if rounding is None:
rounding = jvm_rounding_mode(decimal.getcontext().rounding)
elif rounding in _python_rounding_modes:
rounding = jvm_rounding_mode(rounding)
assert isinstance(rounding, RoundingMode)
context = MathContext(precision, rounding)
if isinstance(value, str):
return BigDecimal.of(value, context)
if isinstance(value, decimal.Decimal):
return BigDecimal.of(jpype.JString @ str(value), context)
if isinstance(value, BigInteger):
return BigDecimal.of(value, context)
if isinstance(value, int):
return BigDecimal.of(big_integer(value), context)
assert isinstance(value, float)
return BigDecimal.of(jpype.JDouble @ value, context)
def python_decimal(value: BigDecimal) -> decimal.Decimal:
return decimal.Decimal(str(value)) | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/_ktmath.py | _ktmath.py |
from tuprolog import logger
import jpype
from tuprolog.core import TermVisitor
@jpype.JImplements(TermVisitor)
class AbstractTermVisitor(object):
@jpype.JOverride
def defaultValue(self, term):
raise NotImplementedError()
@jpype.JOverride
def visitTerm(self, term):
return TermVisitor.DefaultImpls.visitTerm(self, term)
@jpype.JOverride
def visitVar(self, term):
return TermVisitor.DefaultImpls.visitVar(self, term)
@jpype.JOverride
def visitConstant(self, term):
return TermVisitor.DefaultImpls.visitConstant(self, term)
@jpype.JOverride
def visitStruct(self, term):
return TermVisitor.DefaultImpls.visitStruct(self, term)
@jpype.JOverride
def visitCollection(self, term):
return TermVisitor.DefaultImpls.visitCollection(self, term)
@jpype.JOverride
def visitAtom(self, term):
return TermVisitor.DefaultImpls.visitAtom(self, term)
@jpype.JOverride
def visitTruth(self, term):
return TermVisitor.DefaultImpls.visitTruth(self, term)
@jpype.JOverride
def visitNumeric(self, term):
return TermVisitor.DefaultImpls.visitNumeric(self, term)
@jpype.JOverride
def visitInteger(self, term):
return TermVisitor.DefaultImpls.visitInteger(self, term)
@jpype.JOverride
def visitReal(self, term):
return TermVisitor.DefaultImpls.visitReal(self, term)
@jpype.JOverride
def visitBlock(self, term):
return TermVisitor.DefaultImpls.visitBlock(self, term)
@jpype.JOverride
def visitEmpty(self, term):
return TermVisitor.DefaultImpls.visitEmpty(self, term)
@jpype.JOverride
def visitEmptyBlock(self, term):
return TermVisitor.DefaultImpls.visitEmptyBlock(self, term)
@jpype.JOverride
def visitList(self, term):
return TermVisitor.DefaultImpls.visitList(self, term)
@jpype.JOverride
def visitCons(self, term):
return TermVisitor.DefaultImpls.visitCons(self, term)
@jpype.JOverride
def visitEmptyList(self, term):
return TermVisitor.DefaultImpls.visitEmptyList(self, term)
@jpype.JOverride
def visitTuple(self, term):
return TermVisitor.DefaultImpls.visitTuple(self, term)
@jpype.JOverride
def visitIndicator(self, term):
return TermVisitor.DefaultImpls.visitIndicator(self, term)
@jpype.JOverride
def visitClause(self, term):
return TermVisitor.DefaultImpls.visitClause(self, term)
@jpype.JOverride
def visitRule(self, term):
return TermVisitor.DefaultImpls.visitRule(self, term)
@jpype.JOverride
def visitFact(self, term):
return TermVisitor.DefaultImpls.visitFact(self, term)
@jpype.JOverride
def visitDirective(self, term):
return TermVisitor.DefaultImpls.visitDirective(self, term)
logger.debug("Loaded compatibility layer for JVM subtypes of " + str(TermVisitor.class_.getName())) | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/visitors.py | visitors.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype
import jpype.imports
from tuprolog.core import Formatter, TermFormatter
from tuprolog.core.visitors import AbstractTermVisitor
@jpype.JImplements(Formatter)
class AbstractFormatter(object):
@jpype.JOverride
def format(self, term):
raise NotImplementedError()
@jpype.JImplements(TermFormatter)
class AbstractTermFormatter(AbstractFormatter, AbstractTermVisitor):
@jpype.JOverride
def format(self, term):
return term.accept(self)
@jpype.JOverride
def defaultValue(self, term):
return super(AbstractTermVisitor).defaultValue(self, term)
@jpype.JOverride
def visitTerm(self, term):
return super(AbstractTermVisitor, self).visitTerm(term)
@jpype.JOverride
def visitVar(self, term):
return super(AbstractTermVisitor, self).visitVar(term)
@jpype.JOverride
def visitConstant(self, term):
return super(AbstractTermVisitor, self).visitConstant(term)
@jpype.JOverride
def visitStruct(self, term):
return super(AbstractTermVisitor, self).visitStruct(term)
@jpype.JOverride
def visitCollection(self, term):
return super(AbstractTermVisitor, self).visitCollection(term)
@jpype.JOverride
def visitAtom(self, term):
return super(AbstractTermVisitor, self).visitAtom(term)
@jpype.JOverride
def visitTruth(self, term):
return super(AbstractTermVisitor, self).visitTruth(term)
@jpype.JOverride
def visitNumeric(self, term):
return super(AbstractTermVisitor, self).visitNumeric(term)
@jpype.JOverride
def visitInteger(self, term):
return super(AbstractTermVisitor, self).visitInteger(term)
@jpype.JOverride
def visitReal(self, term):
return super(AbstractTermVisitor, self).visitReal(term)
@jpype.JOverride
def visitBlock(self, term):
return super(AbstractTermVisitor, self).visitBlock(term)
@jpype.JOverride
def visitEmpty(self, term):
return super(AbstractTermVisitor, self).visitEmpty(term)
@jpype.JOverride
def visitEmptyBlock(self, term):
return super(AbstractTermVisitor, self).visitEmptyBlock(term)
@jpype.JOverride
def visitList(self, term):
return super(AbstractTermVisitor, self).visitList(term)
@jpype.JOverride
def visitCons(self, term):
return super(AbstractTermVisitor, self).visitCons(term)
@jpype.JOverride
def visitEmptyList(self, term):
return super(AbstractTermVisitor, self).visitEmptyList(term)
@jpype.JOverride
def visitTuple(self, term):
return super(AbstractTermVisitor, self).visitTuple(term)
@jpype.JOverride
def visitIndicator(self, term):
return super(AbstractTermVisitor, self).visitIndicator(term)
@jpype.JOverride
def visitClause(self, term):
return super(AbstractTermVisitor, self).visitClause(term)
@jpype.JOverride
def visitRule(self, term):
return super(AbstractTermVisitor, self).visitRule(term)
@jpype.JOverride
def visitFact(self, term):
return super(AbstractTermVisitor, self).visitFact(term)
@jpype.JOverride
def visitDirective(self, term):
return super(AbstractTermVisitor, self).visitDirective(term)
logger.debug("Loaded compatibility layer for JVM subtypes of " + str(TermFormatter.class_.getName())) | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/formatters.py | formatters.py |
from decimal import Decimal
from tuprolog import logger
import jpype
import jpype.imports
from ._ktadapt import *
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.core as _core
from tuprolog.pyutils import iterable_or_varargs
from tuprolog.jvmutils import jiterable, jmap
from typing import Iterable, Dict, Tuple as PyTuple
Atom = _core.Atom
Block = _core.Block
Clause = _core.Clause
Cons = _core.Cons
Constant = _core.Constant
Directive = _core.Directive
Empty = _core.Empty
EmptyBlock = _core.EmptyBlock
EmptyList = _core.EmptyList
Fact = _core.Fact
Formatter = _core.Formatter
Indicator = _core.Indicator
Integer = _core.Integer
List = _core.List
Numeric = _core.Numeric
Real = _core.Real
Recursive = _core.Recursive
Rule = _core.Rule
Scope = _core.Scope
Struct = _core.Struct
Substitution = _core.Substitution
Term = _core.Term
TermComparator = _core.TermComparator
TermConvertible = _core.TermConvertible
TermFormatter = _core.TermFormatter
Terms = _core.Terms
TermVisitor = _core.TermVisitor
Truth = _core.Truth
Tuple = _core.Tuple
Var = _core.Var
@jpype.JImplements(TermConvertible)
class AbstractTermConvertible(object):
@jpype.JOverride
def toTerm(self):
raise NotImplementedError()
def atom(string: str) -> Atom:
return Atom.of(string)
def block(*terms: Union[Term, Iterable[Term]]) -> Block:
return iterable_or_varargs(terms, lambda ts: Block.of(jiterable(ts)))
def clause(head: Term = None, *body: Union[Term, Iterable[Term]]):
return iterable_or_varargs(body, lambda bs: Clause.of(head, jiterable(bs)))
def empty_logic_list() -> EmptyList:
return EmptyList.getInstance()
def cons(head: Term, tail: Term = None) -> Cons:
if tail is None:
return Cons.singleton(head)
else:
return Cons.of(head, tail)
def directive(*goals: Union[Term, Iterable[Term]]) -> Directive:
return iterable_or_varargs(goals, lambda gs: Directive.of(jiterable(gs)))
def empty_block() -> Block:
return EmptyBlock.getInstance()
def fact(struct: Union[Term, Iterable[Term]]) -> Fact:
return Fact.of(struct)
def indicator(name: Union[str, Term], arity: Union[int, Term]) -> Indicator:
return Indicator.of(name, arity)
def integer(value: Union[int, BigInteger, str]) -> Integer:
return Integer.of(big_integer(value))
def real(value: Union[float, BigDecimal, str, Decimal]) -> Real:
return Real.of(big_decimal(value))
def numeric(value: Union[int, BigInteger, BigDecimal, str, float, Decimal]) -> Numeric:
if isinstance(value, str):
return Numeric.of(jpype.JString @ value)
if isinstance(value, int) or isinstance(value, BigInteger):
return integer(value)
return real(value)
def rule(head: Struct, *body: Union[Term, Iterable[Term]]) -> Rule:
return iterable_or_varargs(body, lambda bs: Rule.of(head, jiterable(bs)))
def struct(functor: str, *args: Union[Term, Iterable[Term]]) -> Struct:
return iterable_or_varargs(args, lambda xs: Struct.of(functor, jiterable(xs)))
def truth(boolean: bool) -> Truth:
return Truth.of(boolean)
TRUE = Truth.TRUE
FALSE = Truth.FALSE
FAIL = Truth.FAIL
def logic_list(*items: Union[Term, Iterable[Term]]) -> List:
return iterable_or_varargs(items, lambda xs: List.of(jiterable(xs)))
def logic_list_from(items: Iterable[Term], last: Term = None) -> List:
return List.from_(jiterable(items), last)
def logic_tuple(first: Term, second: Term, *others: Union[Term, Iterable[Term]]) -> Tuple:
return iterable_or_varargs(others, lambda os: Tuple.of(jiterable([first, second] + list(os))))
def var(name: str) -> Var:
return Var.of(name)
def unifier(assignments: Dict[Var, Term] = {}) -> Substitution.Unifier:
return Substitution.unifier(jmap(assignments))
def substitution(assignments: Dict[Var, Term] = {}) -> Substitution:
return Substitution.of(jmap(assignments))
def failed() -> Substitution.Fail:
return Substitution.failed()
EMPTY_UNIFIER: Substitution.Unifier = substitution()
FAILED_SUBSTITUTION: Substitution.Fail = failed()
def scope(*variables: Union[Var, str]) -> Scope:
if len(variables) == 0:
return Scope.empty()
vars = [var(v) if isinstance(v, str) else v for v in variables]
return Scope.of(jpype.JArray(Var) @ vars)
def variables(*names: str) -> PyTuple[Var]:
assert len(names) > 0
return tuple((var(n) for n in names))
logger.debug("Loaded JVM classes from it.unibo.tuprolog.core.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/__init__.py | __init__.py |
from tuprolog import logger
import jpype
from tuprolog.jvmioutils import ensure_input_steam
@jpype.JImplementationFor("it.unibo.tuprolog.core.parsing.TermParser")
class _KtTermParser:
def __jclass_init__(cls):
pass
@property
def default_operator_set(self):
return self.getDefaultOperatorSet()
def _parse(self, method, input, operators):
if operators is None:
return method(input)
else:
return method(input, operators)
def parse(self, input, operators=None):
return self.parse_term(input, operators)
def parse_term(self, input, operators=None):
return self._parse(self.parseTerm, input, operators)
def parse_struct(self, input, operators=None):
return self._parse(self.parseStruct, input, operators)
def parse_constant(self, input, operators=None):
return self._parse(self.parseConstant, input, operators)
def parse_var(self, input, operators=None):
return self._parse(self.parseVar, input, operators)
def parse_atom(self, input, operators=None):
return self._parse(self.parseAtom, input, operators)
def parse_numeric(self, input, operators=None):
return self._parse(self.parseNumeric, input, operators)
def parse_integer(self, input, operators=None):
return self._parse(self.parseInteger, input, operators)
def parse_real(self, input, operators=None):
return self._parse(self.parseReal, input, operators)
def parse_clause(self, input, operators=None):
return self._parse(self.parseClause, input, operators)
@jpype.JImplementationFor("it.unibo.tuprolog.core.parsing.TermReader")
class _KtTermReader:
def __jclass_init__(cls):
pass
@property
def default_operator_set(self):
return self.getDefaultOperatorSet()
def _read(self, method, input, operators):
input_stream = ensure_input_steam(input)
if operators is None:
return method(input_stream)
else:
return method(input_stream, operators)
def read(self, input, operators=None):
return self.read_term(input, operators)
def read_term(self, input, operators=None):
return self._read(self.readTerm, input, operators)
def read_all(self, input, operators=None):
return self.read_terms(input, operators)
def read_terms(self, input, operators=None):
return self._read(self.readTerms, input, operators)
logger.debug("Configure Kotlin adapters for types in it.unibo.tuprolog.core.parsing.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/parsing/_ktadapt.py | _ktadapt.py |
from tuprolog import logger
# noinspection PyUnresolvedReferences
import jpype.imports
# noinspection PyUnresolvedReferences
import it.unibo.tuprolog.core.parsing as _parsing
from tuprolog.core import Term, Struct, Constant, Var, Atom, Numeric, Integer, Real, Clause
from tuprolog.jvmutils import InputStream
from tuprolog.core.operators import OperatorSet, DEFAULT_OPERATORS
from typing import Union, Iterable
from ._ktadapt import *
TermParser = _parsing.TermParser
TermReader = _parsing.TermReader
ParseException = _parsing.ParseException
InvalidTermTypeException = _parsing.InvalidTermTypeException
def _factory(source, with_default_operators: bool = True, operators: OperatorSet = None):
if operators is None:
if with_default_operators:
return source.getWithDefaultOperators()
else:
return source.getWithNoOperator()
else:
if with_default_operators:
return source.withOperators(DEFAULT_OPERATORS.plus(operators))
else:
return source.withOperators(operators)
def term_parser(with_default_operators: bool = True, operators: OperatorSet = None) -> TermParser:
return _factory(TermParser, with_default_operators, operators)
def term_reader(with_default_operators: bool = True, operators: OperatorSet = None) -> TermParser:
return _factory(TermReader, with_default_operators, operators)
DEFAULT_TERM_PARSER = term_parser()
DEFAULT_TERM_READER = term_reader()
def parse_term(string: str, operators: OperatorSet = None) -> Term:
return DEFAULT_TERM_PARSER.parse_term(string, operators)
def parse_struct(string: str, operators: OperatorSet = None) -> Struct:
return DEFAULT_TERM_PARSER.parse_struct(string, operators)
def parse_constant(string: str, operators: OperatorSet = None) -> Constant:
return DEFAULT_TERM_PARSER.parse_constant(string, operators)
def parse_var(string: str, operators: OperatorSet = None) -> Var:
return DEFAULT_TERM_PARSER.parse_var(string, operators)
def parse_atom(string: str, operators: OperatorSet = None) -> Atom:
return DEFAULT_TERM_PARSER.parse_atom(string, operators)
def parse_numeric(string: str, operators: OperatorSet = None) -> Numeric:
return DEFAULT_TERM_PARSER.parse_numeric(string, operators)
def parse_integer(string: str, operators: OperatorSet = None) -> Integer:
return DEFAULT_TERM_PARSER.parse_integer(string, operators)
def parse_real(string: str, operators: OperatorSet = None) -> Real:
return DEFAULT_TERM_PARSER.parse_real(string, operators)
def parse_clause(string: str, operators: OperatorSet = None) -> Clause:
return DEFAULT_TERM_PARSER.parse_clause(string, operators)
def read_term(input: Union[InputStream, str], operators: OperatorSet = None) -> Term:
return DEFAULT_TERM_READER.read_term(input, operators)
def read_terms(input: Union[InputStream, str], operators: OperatorSet = None) -> Iterable[Term]:
return DEFAULT_TERM_READER.read_terms(input, operators)
logger.debug("Loaded JVM classes from it.unibo.tuprolog.core.parsing.*") | 2ppy | /2ppy-0.4.0-py3-none-any.whl/tuprolog/core/parsing/__init__.py | __init__.py |
# __ (Double Underscores, 2us)
Glueing functionals by `import __` for python!
## Install
The package is written in pure python, with no dependencies other than the Python language. Just do:
```sh
pip install 2us
```
Requires Python 3.5 or higher.
## Why this?
Python is a great language for creating convenient wrappers around native code and implementing simple, human-friendly functions.
In python, a bunch of builtin higher-order methods (which means that they accept functions as arguments) such as `map`, `filter` are available.
They enable streamed data processing on containers that focus on the processing itself,
in contrast with *noisy code* on traditional command-based languages that is heavily involved in loops.
However, you may occasionally run into the situatiion where you find that there is no standard library functions to implement in-line unpacking of tuples,
adding all numbers in a list by a constant shift, so you will have to write:
```python
map(lambda x: x + 1, some_list)
map(lambda x: x[0], some_list)
```
which seems rather dumb due to the inconvenient definition of lambda functions in python.
## Using __
Start using the package by importing `__`:
```python
import __
```
And then `__` can be used to create convenient functions that are identical to those written with `lambda`. Examples:
```python
assert sum(map(__ + 1, range(1000))) == sum(map(lambda x: x + 1, range(1000)))
assert set(map(__[0], {1: 2, 4: 6}.items())) == {1, 4}
assert functools.reduce(__ + __, range(1000)) == sum(range(1000))
```
Currently there is a drawback: python do not support overriding `__contains__` returning non-boolean values, so the `in` condition should be handled separately.
```python
assert tuple(map(__.is_in([1, 2]), [3, 1, 5, 0, 2])) == (False, True, False, False, True)
assert list(map(__.contains('1'), '13')) == [True, False]
```
| 2us | /2us-0.0.1.tar.gz/2us-0.0.1/README.md | README.md |
import sys
import operator
import functools
from types import ModuleType
class LambdaProxyModule(ModuleType):
def __getattr__(self, name):
return lambda x: getattr(x, name)
def __call__(self, *args, **kwargs):
return lambda x: x(*args, **kwargs)
def __getitem__(self, key):
return operator.itemgetter(key)
def is_in(self, it):
return functools.partial(operator.contains, it)
def contains(self, other):
if self is other:
return lambda x, y: y in x
return lambda x: other in x
def __lt__(self, other):
if self is other:
return operator.__lt__
return lambda x: x < other
def __le__(self, other):
if self is other:
return operator.__le__
return lambda x: x <= other
def __eq__(self, other):
if self is other:
return operator.__eq__
return lambda x: x == other
def __ne__(self, other):
if self is other:
return operator.__ne__
return lambda x: x != other
def __gt__(self, other):
if self is other:
return operator.__gt__
return lambda x: x > other
def __ge__(self, other):
if self is other:
return operator.__ge__
return lambda x: x >= other
def __add__(self, other):
if self is other:
return operator.__add__
return lambda x: x + other
def __sub__(self, other):
if self is other:
return operator.__sub__
return lambda x: x - other
def __mul__(self, other):
if self is other:
return operator.__mul__
return lambda x: x * other
def __matmul__(self, other):
if self is other:
return operator.__matmul__
return lambda x: x @ other
def __truediv__(self, other):
if self is other:
return operator.__truediv__
return lambda x: x / other
def __floordiv__(self, other):
if self is other:
return operator.__floordiv__
return lambda x: x // other
def __mod__(self, other):
if self is other:
return operator.__mod__
return lambda x: x % other
def __pow__(self, other):
if self is other:
return operator.__pow__
return lambda x: x ** other
def __lshift__(self, other):
if self is other:
return operator.__lshift__
return lambda x: x << other
def __rshift__(self, other):
if self is other:
return operator.__rshift__
return lambda x: x >> other
def __and__(self, other):
if self is other:
return operator.__and__
return lambda x: x & other
def __xor__(self, other):
if self is other:
return operator.__xor__
return lambda x: x ^ other
def __or__(self, other):
if self is other:
return operator.__or__
return lambda x: x | other
def __radd__(self, other):
if self is other:
return lambda x, y: y + x
return lambda x: other + x
def __rsub__(self, other):
if self is other:
return lambda x, y: y - x
return lambda x: other - x
def __rmul__(self, other):
if self is other:
return lambda x, y: y * x
return lambda x: other * x
def __rmatmul__(self, other):
if self is other:
return lambda x, y: y @ x
return lambda x: other @ x
def __rtruediv__(self, other):
if self is other:
return lambda x, y: y / x
return lambda x: other / x
def __rfloordiv__(self, other):
if self is other:
return lambda x, y: y // x
return lambda x: other // x
def __rmod__(self, other):
if self is other:
return lambda x, y: y % x
return lambda x: other % x
def __rpow__(self, other):
if self is other:
return lambda x, y: y ** x
return lambda x: other ** x
def __rlshift__(self, other):
if self is other:
return lambda x, y: y << x
return lambda x: other << x
def __rrshift__(self, other):
if self is other:
return lambda x, y: y >> x
return lambda x: other >> x
def __rand__(self, other):
if self is other:
return lambda x, y: y & x
return lambda x: other & x
def __rxor__(self, other):
if self is other:
return lambda x, y: y ^ x
return lambda x: other ^ x
def __ror__(self, other):
if self is other:
return lambda x, y: y | x
return lambda x: other | x
sys.modules[__name__].__class__ = LambdaProxyModule | 2us | /2us-0.0.1.tar.gz/2us-0.0.1/__/__init__.py | __init__.py |
2vyper is an automatic verifier for smart contracts written in Vyper, based on the `Viper <http://viper.ethz.ch>`_ verification infrastructure. It is being developed at the `Programming Methodology Group <http://www.pm.inf.ethz.ch/>`_ at ETH Zurich. 2vyper was mainly developed by Robin Sierra, Christian Bräm, and Marco Eilers.
For examples of the provided specification constructs, check out the `examples folder <tests/resources/examples>`_. Note that the examples are written in Vyper 0.1.0, but 2vyper supports different versions if a version pragma is set.
A short overview of the most important specification constructs can be found `here <docs/specifications.md>`_.
For further documentation, read `our paper <https://arxiv.org/abs/2104.10274>`_ about 2vyper's specification constructs, `Robin Sierra's <https://ethz.ch/content/dam/ethz/special-interest/infk/chair-program-method/pm/documents/Education/Theses/Robin_Sierra_MA_Report.pdf>`_ and `Christian Bräm's <https://ethz.ch/content/dam/ethz/special-interest/infk/chair-program-method/pm/documents/Education/Theses/Christian%20Br%C3%A4m_MS_Report.pdf>`_ Master's theses on the tool.
Dependencies (Ubuntu Linux, MacOS)
===================================
Install Java >= 11 (64 bit) and Python >= 3.7 (64 bit).
For usage with the Viper's verification condition generation backend Carbon, you will also need to install the .NET / the Mono runtime.
Dependencies (Windows)
==========================
1. Install Java >= 11 (64 bit) and Python >= 3.7 (64 bit).
2. Install either Visual C++ Build Tools 2015 (http://go.microsoft.com/fwlink/?LinkId=691126) or Visual Studio 2015. For the latter, make sure to choose the option "Common Tools for Visual C++ 2015" in the setup (see https://blogs.msdn.microsoft.com/vcblog/2015/07/24/setup-changes-in-visual-studio-2015-affecting-c-developers/ for an explanation).
Getting Started
===============
1. Clone the 2vyper repository::
git clone https://github.com/viperproject/2vyper
cd 2vyper/
2. Create a virtual environment and activate it::
virtualenv env
source env/bin/activate
3. Install 2vyper::
pip install .
Command Line Usage
==================
To verify a specific file from the 2vyper directory, run::
2vyper [OPTIONS] path-to-file.vy
The following command line options are available::
``--verifier``
Selects the Viper backend to use for verification.
Possible options are ``silicon`` (for Symbolic Execution) and ``carbon``
(for Verification Condition Generation based on Boogie).
Default: ``silicon``.
``--viper-jar-path``
Sets the path to the required Viper binaries (``silicon.jar`` or
``carbon.jar``). Only the binary for the selected backend is
required. We recommend that you use the provided binary
packages installed by default, but you can or compile your own from
source.
Expects either a single path or a colon- (Unix) or semicolon-
(Windows) separated list of paths. Alternatively, the environment
variables ``SILICONJAR``, ``CARBONJAR`` or ``VIPERJAR`` can be set.
``--z3``
Sets the path of the Z3 executable. Alternatively, the
``Z3_EXE`` environment variable can be set.
``--boogie``
Sets the path of the Boogie executable. Required if the Carbon backend
is selected. Alternatively, the ``BOOGIE_EXE`` environment variable can be
set.
``--counterexample``
Produces a counterexample if the verification fails. Currently only works
with the default ``silicon`` backend.
``--vyper-root``
Sets the root directory for the Vyper compiler.
``--skip-vyper``
Skips type checking the given Vyper program using the Vyper compiler.
``--print-viper``
Print the generated Viper file to the command line.
To see all possible command line options, invoke ``2vyper`` without arguments.
Alternative Viper Versions
==========================
To use a custom version of the Viper infrastructure, follow the
`instructions here <https://bitbucket.org/viperproject/documentation/wiki/Home>`_. Look for
``sbt assembly`` to find instructions for packaging the required JAR files. Use the
parameters mentioned above to instruct 2vyper to use your custom Viper version.
Note that 2vyper may not always work with the most recent Viper version.
Troubleshooting
=======================
1. On Windows: During the setup, you get an error like ``Microsoft Visual C++ 14.0 is required.`` or ``Unable to fnd vcvarsall.bat``:
Python cannot find the required Visual Studio 2015 C++ installation, make sure you have either installed the Build Tools or checked the "Common Tools" option in your regular VS 2015 installation (see above).
2. While verifying a file, you get a stack trace ending with something like ``No matching overloads found``:
The version of Viper you're using does not match your version of 2vyper. Try using the the one that comes with 2vyper instead.
Build Status
============
.. image:: https://pmbuilds.inf.ethz.ch/buildStatus/icon?job=2vyper-linux-xenial&style=plastic
:alt: Build Status
:target: https://pmbuilds.inf.ethz.ch/job/2vyper-linux-xenial
| 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/README.rst | README.rst |
import os
import sys
import shutil
import twovyper.backends
def _backend_path(verifier: str):
backends = os.path.dirname(twovyper.backends.__file__)
return os.path.join(backends, f'{verifier}.jar')
def _sif_path():
backends = os.path.dirname(twovyper.backends.__file__)
return os.path.join(backends, 'silver-sif-extension.jar')
def _executable_path(cmd: str, env: str = None) -> str:
if env:
env_var = os.environ.get(env)
if env_var:
return env_var
return shutil.which(cmd, os.X_OK)
def _construct_classpath(verifier: str = 'silicon'):
""" Contstructs JAVA classpath.
First tries environment variables ``VIPERJAVAPATH``, ``SILICONJAR``
and ``CARBONJAR``. If they are undefined, then uses packaged backends.
"""
viper_java_path = os.environ.get('VIPERJAVAPATH')
silicon_jar = os.environ.get('SILICONJAR')
carbon_jar = os.environ.get('CARBONJAR')
sif_jar = os.environ.get('SIFJAR')
if viper_java_path:
return viper_java_path
if silicon_jar and verifier == 'silicon':
verifier_path = silicon_jar
elif carbon_jar and verifier == 'carbon':
verifier_path = carbon_jar
else:
verifier_path = _backend_path(verifier)
sif_path = sif_jar or _sif_path()
return os.pathsep.join([verifier_path, sif_path])
def _get_boogie_path():
""" Tries to detect path to Boogie executable.
First tries the environment variable ``BOOGIE_EXE``. If it is not
defined, it uses the system default.
"""
cmd = 'Boogie.exe' if sys.platform.startswith('win') else 'boogie'
return _executable_path(cmd, 'BOOGIE_EXE')
def _get_z3_path():
""" Tries to detect path to Z3 executable.
First tries the environment variable ``Z3_EXE``. If it is not defined,
it uses the system default (which is probably the one installed by the dependency).
"""
cmd = 'z3.exe' if sys.platform.startswith('win') else 'z3'
return _executable_path(cmd, 'Z3_EXE')
def set_classpath(v: str):
global classpath
classpath = _construct_classpath(v)
classpath = _construct_classpath()
z3_path = _get_z3_path()
boogie_path = _get_boogie_path() | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/config.py | config.py |
import argparse
import logging
import os
from time import time
from jpype import JException
########################################################################################################################
# DO NOT GLOBALLY IMPORT ANY SUBMODULE OF TWOVYPER THAT MIGHT DEPEND ON THE VYPER VERSION! #
########################################################################################################################
from twovyper import config
from twovyper import vyper
from twovyper.utils import reload_package
from twovyper.viper.jvmaccess import JVM
from twovyper.viper.typedefs import Program
from twovyper.exceptions import (
InvalidVyperException, ParseException, UnsupportedException, InvalidProgramException, ConsistencyException
)
class TwoVyper:
def __init__(self, jvm: JVM, get_model: bool = False, check_ast_inconsistencies: bool = False):
self.jvm = jvm
self.get_model = get_model
self.check_ast_inconsistencies = check_ast_inconsistencies
def translate(self, path: str, vyper_root: str = None, skip_vyper: bool = False) -> Program:
path = os.path.abspath(path)
if not os.path.isfile(path):
raise InvalidVyperException(f"Contract not found at the given location '{path}'.")
vyper.set_vyper_version(path)
from twovyper.verification import error_manager
error_manager.clear()
# Check that the file is a valid Vyper contract
if not skip_vyper:
vyper.check(path, vyper_root)
logging.debug("Start parsing.")
from twovyper.parsing import parser
vyper_program = parser.parse(path, vyper_root, name=os.path.basename(path.split('.')[0]))
logging.info("Finished parsing.")
logging.debug("Start analyzing.")
from twovyper.analysis import analyzer
for interface in vyper_program.interfaces.values():
analyzer.analyze(interface)
analyzer.analyze(vyper_program)
logging.info("Finished analyzing.")
logging.debug("Start translating.")
from twovyper.translation import translator
from twovyper.translation.translator import TranslationOptions
options = TranslationOptions(self.get_model, self.check_ast_inconsistencies)
translated = translator.translate(vyper_program, options, self.jvm)
logging.info("Finished translating.")
return translated
def verify(self, program: Program, path: str, backend: str) -> 'VerificationResult':
"""
Verifies the given Viper program
"""
logging.debug("Start verifying.")
from twovyper.verification.verifier import (
VerificationResult,
ViperVerifier, AbstractVerifier
)
verifier: AbstractVerifier = ViperVerifier[backend].value
result = verifier.verify(program, self.jvm, path, self.get_model)
logging.info("Finished verifying.")
return result
def main() -> None:
"""
Entry point for the verifier.
"""
parser = argparse.ArgumentParser()
parser.add_argument(
'vyper_file',
help='Python file to verify'
)
parser.add_argument(
'--verifier',
help='verifier to be used (carbon or silicon)',
choices=['silicon', 'carbon'],
default='silicon'
)
parser.add_argument(
'--viper-jar-path',
help='Java CLASSPATH that includes Viper class files',
default=None
)
parser.add_argument(
'--z3',
help='path to Z3 executable',
default=config.z3_path
)
parser.add_argument(
'--boogie',
help='path to Boogie executable',
default=config.boogie_path
)
parser.add_argument(
'--counterexample',
action='store_true',
help='print a counterexample if the verification fails',
)
parser.add_argument(
'--check-ast-inconsistencies',
action='store_true',
help='Check the generated Viper AST for potential inconsistencies.',
)
parser.add_argument(
'--vyper-root',
help='import root directory for the Vyper contract',
default=None
)
parser.add_argument(
'--skip-vyper',
action='store_true',
help='skip validity check of contract with the Vyper compiler'
)
parser.add_argument(
'--print-viper',
action='store_true',
help='print generated Viper program'
)
parser.add_argument(
'--write-viper-to-file',
default=None,
help='write generated Viper program to specified file'
)
parser.add_argument(
'--log',
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
help='log level',
default='WARNING'
)
parser.add_argument(
'--benchmark',
type=int,
help='run verification the given number of times to benchmark performance',
default=-1
)
parser.add_argument(
'--ide-mode',
action='store_true',
help='output errors in IDE format'
)
args = parser.parse_args()
if args.viper_jar_path:
config.classpath = args.viper_jar_path
else:
config.set_classpath(args.verifier)
config.boogie_path = args.boogie
config.z3_path = args.z3
if not config.classpath:
parser.error('missing argument: --viper-jar-path')
if not config.z3_path:
parser.error('missing argument: --z3')
if args.verifier == 'carbon' and not config.boogie_path:
parser.error('missing argument: --boogie')
if args.verifier == 'carbon' and args.counterexample:
parser.error('counterexamples are only supported with the Silicon backend')
formatter = logging.Formatter()
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logging.basicConfig(level=args.log, handlers=[handler])
jvm = JVM(config.classpath)
translate_and_verify(args.vyper_file, jvm, args)
def translate_and_verify(vyper_file, jvm, args, print=print):
try:
start = time()
tw = TwoVyper(jvm, args.counterexample, args.check_ast_inconsistencies)
program = tw.translate(vyper_file, args.vyper_root, args.skip_vyper)
if args.print_viper:
print(str(program))
if args.write_viper_to_file:
with open(args.write_viper_to_file, 'w') as fp:
fp.write(str(program))
backend = args.verifier
if args.benchmark >= 1:
print("Run, Total, Start, End, Time")
for i in range(args.benchmark):
start = time()
prog = tw.translate(vyper_file, args.vyper_root, args.skip_vyper)
vresult = tw.verify(prog, vyper_file, backend)
end = time()
print(f"{i}, {args.benchmark}, {start}, {end}, {end - start}")
else:
vresult = tw.verify(program, vyper_file, backend)
print(vresult.string(args.ide_mode, include_model=args.counterexample))
end = time()
duration = end - start
print(f"Verification took {duration:.2f} seconds.")
except (InvalidProgramException, UnsupportedException) as e:
print(e.error_string())
except ConsistencyException as e:
print(e.program)
print(e.message)
for error in e.errors:
print(error.toString())
except (InvalidVyperException, ParseException) as e:
print(e.message)
except JException as e:
print(e.stacktrace())
raise e
def prepare_twovyper_for_vyper_version(path: str) -> bool:
"""
Checks if the current loaded vyper version differs from the vyper version used in a vyper contract.
If it does differ, reload the whole twovyper module.
Please note that all references (e.g. via a "from ... import ...") to the twovyper module are not refreshed
automatically. Therefore, use this function with caution.
:param path: The path to a vyper contract.
:return: True iff a reload of the module was performed.
"""
version = vyper.get_vyper_version()
vyper.set_vyper_version(path)
if version != vyper.get_vyper_version():
import twovyper
reload_package(twovyper)
return True
return False
if __name__ == '__main__':
main() | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/main.py | main.py |
import importlib
import os
from contextlib import contextmanager
from types import ModuleType
from typing import Callable, Iterable, List, Optional, TypeVar
_ = object()
@contextmanager
def switch(*values):
def match(*v, where=True):
if not where or len(values) != len(v):
return False
return all(case is _ or actual == case for actual, case in zip(values, v))
yield match
T = TypeVar('T')
def first(iterable: Iterable[T]) -> Optional[T]:
return next(iter(iterable), None)
def first_index(statisfying: Callable[[T], bool], l) -> int:
return next((i for i, v in enumerate(l) if statisfying(v)), -1)
def flatten(iterables: Iterable[Iterable[T]]) -> List[T]:
return [item for subiterable in iterables for item in subiterable]
def unique(eq, iterable: Iterable[T]) -> List[T]:
unique_iterable: List[T] = []
for elem in iterable:
for uelem in unique_iterable:
if eq(elem, uelem):
break
else:
unique_iterable.append(elem)
return unique_iterable
def seq_to_list(scala_iterable):
lst = []
it = scala_iterable.iterator()
while it.hasNext():
lst.append(it.next())
return lst
def list_to_seq(lst, jvm):
seq = jvm.scala.collection.mutable.ArraySeq(len(lst))
for i, element in enumerate(lst):
seq.update(i, element)
return seq
def reload_package(package):
assert(hasattr(package, "__package__"))
fn = package.__file__
fn_dir = os.path.dirname(fn) + os.sep
module_visit = {fn}
del fn
# Reloading all modules in a depth first search matter starting from "package".
def reload_recursive_ex(module):
importlib.reload(module)
for module_child in vars(module).values():
if isinstance(module_child, ModuleType):
fn_child = getattr(module_child, "__file__", None)
if (fn_child is not None) and fn_child.startswith(fn_dir):
if fn_child not in module_visit:
module_visit.add(fn_child)
reload_recursive_ex(module_child)
reload_recursive_ex(package)
class Subscriptable(type):
"""
A metaclass to add dictionary lookup functionality to a class.
The class needs to implement the `_subscript(_)` method.
"""
def __getitem__(cls, val):
return cls._subscript(val) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/utils.py | utils.py |
import logging
import os
import re
from subprocess import Popen, PIPE
from typing import Optional, List, Dict, TypeVar
import vvm
import vyper
from semantic_version import NpmSpec, Version
from vvm.utils.convert import to_vyper_version
from twovyper.exceptions import InvalidVyperException, UnsupportedVersionException
try:
# noinspection PyUnresolvedReferences,PyUnboundLocalVariable
_imported
except NameError:
_imported = True # means the module is being imported
else:
_imported = False # means the module is being reloaded
if _imported:
_original_get_executable = vvm.install.get_executable
def _get_executable(version=None, vvm_binary_path=None) -> str:
path = _original_get_executable(version, vvm_binary_path)
return os.path.abspath(path)
_version_pragma_pattern = re.compile(r"(?:\n|^)\s*#\s*@version\s*([^\n]*)")
_comment_pattern = re.compile(r"(?:\n|^)\s*(#|$)")
_VYPER_VERSION = to_vyper_version(vyper.__version__)
_installed_vyper_versions: Optional[List[Version]] = None
_available_vyper_versions: Optional[List[Version]] = None
_current_vyper_version: Optional[Version] = None
_cache_of_parsed_version_strings: Dict[str, NpmSpec] = {}
# noinspection PyUnboundLocalVariable
vvm.install.get_executable = _get_executable
def _parse_version_string(version_str: str) -> NpmSpec:
result = _cache_of_parsed_version_strings.get(version_str)
if result is not None:
return result
try:
result = NpmSpec(version_str)
except ValueError:
try:
version = to_vyper_version(version_str)
result = NpmSpec(str(version))
except Exception:
raise InvalidVyperException(f"Cannot parse Vyper version from pragma: {version_str}")
_cache_of_parsed_version_strings[version_str] = result
return result
def _get_vyper_pragma_spec(path: str) -> NpmSpec:
pragma_string = None
with open(path, 'r') as file:
for line in file:
pragma_match = _version_pragma_pattern.match(line)
if pragma_match is not None:
pragma_string = pragma_match.groups()[0]
pragma_string = " ".join(pragma_string.split())
break
comment_match = _comment_pattern.match(line)
if comment_match is None:
# version pragma has to comme before code
break
if pragma_string is None:
pragma_string = vyper.__version__
logging.warning(f'No version pragma found. (Using vyper version "{pragma_string}" instead.)')
return _parse_version_string(pragma_string)
def _find_vyper_version(file: str) -> str:
global _installed_vyper_versions
if _installed_vyper_versions is None:
_installed_vyper_versions = vvm.get_installed_vyper_versions()
_installed_vyper_versions.append(_VYPER_VERSION)
pragma_specs = _get_vyper_pragma_spec(file)
version = pragma_specs.select(_installed_vyper_versions)
if not version:
global _available_vyper_versions
if _available_vyper_versions is None:
_available_vyper_versions = vvm.get_installable_vyper_versions()
version = pragma_specs.select(_available_vyper_versions)
if not version:
raise InvalidVyperException(f"Invalid vyper version pragma: {pragma_specs}")
lock = vvm.install.get_process_lock(f"locked${version}")
with lock:
try:
_get_executable(version)
except vvm.exceptions.VyperNotInstalled:
vvm.install_vyper(version)
if version not in _installed_vyper_versions:
_installed_vyper_versions.append(version)
return version
def check(file: str, root=None):
"""
Checks that the file is a valid Vyper contract. If not, throws an `InvalidVyperException`.
"""
if _VYPER_VERSION == _current_vyper_version:
path_str = 'vyper'
else:
path = _get_executable(_current_vyper_version)
path_str = os.path.abspath(path)
pipes = Popen([path_str, file], stdout=PIPE, stderr=PIPE, cwd=root)
_, stderr = pipes.communicate()
if pipes.returncode != 0:
err_msg = stderr.strip().decode('utf-8')
raise InvalidVyperException(err_msg)
def get_vyper_version() -> Version:
if _current_vyper_version is None:
return _VYPER_VERSION
return _current_vyper_version
def set_vyper_version(file: str):
global _current_vyper_version
_current_vyper_version = _find_vyper_version(file)
def is_compatible_version(version: str) -> bool:
vyper_version = get_vyper_version()
specs = _parse_version_string(version)
return specs.match(vyper_version)
T = TypeVar('T')
def select_version(value_dict: Dict[str, T], default: T = None) -> T:
for version_str, value in value_dict.items():
if is_compatible_version(version_str):
return value
else:
if default is None:
raise UnsupportedVersionException()
return default | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/vyper.py | vyper.py |
import os
from twovyper.ast import ast_nodes as ast
from twovyper.ast.text import pprint
class TwoVyperException(Exception):
def __init__(self, message: str):
self.message = message
class InvalidVyperException(TwoVyperException):
"""
Exception indicating that the file is not a valid Vyper contract.
"""
def __init__(self, vyper_output: str):
message = f"Not a valid Vyper contract:\n{vyper_output}"
super().__init__(message)
class ParseException(TwoVyperException):
"""
Exception that is thrown if the contract cannot be parsed.
"""
def __init__(self, message: str):
super().__init__(message)
class TranslationException(TwoVyperException):
def __init__(self, node: ast.Node, message: str):
super().__init__(message)
self.node = node
def error_string(self) -> str:
file_name = os.path.basename(self.node.file)
line = self.node.lineno
col = self.node.col_offset
return f"{self.message} ({file_name}@{line}.{col})"
class UnsupportedException(TranslationException):
"""
Exception that is thrown when attempting to translate a Vyper element not
currently supported.
"""
def __init__(self, node: ast.Node, message: str = None):
self.node = node
if not message:
message = pprint(node)
super().__init__(node, f"Not supported: {message}")
class InvalidProgramException(TranslationException):
"""
Signals that the input program is invalid and cannot be translated.
"""
def __init__(self, node: ast.Node, reason_code: str, message: str = None):
self.node = node
self.code = 'invalid.program'
self.reason_code = reason_code
if not message:
node_msg = pprint(node, True)
message = f"Node\n{node_msg}\nnot allowed here."
super().__init__(node, f"Invalid program ({self.reason_code}): {message}")
class ConsistencyException(TwoVyperException):
"""
Exception reporting that the translated AST has a consistency error.
"""
def __init__(self, program, message: str, errors):
super().__init__(message)
self.program = program
self.errors = errors
class UnsupportedVersionException(TwoVyperException):
"""
Exception that is thrown when a unsupported Vyper version is used by a contract.
"""
def __init__(self, message: str = None):
if message is None:
from twovyper.vyper import get_vyper_version
message = f"The Vyper version ({get_vyper_version()}) used by the contract is not supported."
super().__init__(message) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/exceptions.py | exceptions.py |
import os
from twovyper.ast import names
from twovyper.ast.nodes import VyperProgram, VyperInterface
from twovyper.exceptions import InvalidProgramException
from twovyper.utils import first
def check_symbols(program: VyperProgram):
_check_ghost_functions(program)
_check_ghost_implements(program)
_check_resources(program)
def _check_resources(program: VyperProgram):
if not isinstance(program, VyperInterface):
node = first(program.node.stmts) or program.node
for interface in program.interfaces.values():
for resource_name, resources_list in interface.resources.items():
for resource in resources_list:
if resource.file is None:
if program.resources.get(resource_name) is None:
if not program.config.has_option(names.CONFIG_ALLOCATION):
raise InvalidProgramException(node, 'alloc.not.alloc',
f'The interface "{interface.name}" uses the '
f'allocation config option. Therefore, this contract '
f'also has to enable this config option.')
raise InvalidProgramException(node, 'missing.resource',
f'The interface "{interface.name}" '
f'needs a default resource "{resource_name}" '
f'that is not present in this contract.')
continue
imported_resources = [r for r in program.resources.get(resource_name, [])
if r.file == resource.file]
if not imported_resources:
prefix_length = len(os.path.commonprefix([resource.file, program.file]))
raise InvalidProgramException(node, 'missing.resource',
f'The interface "{interface.name}" '
f'needs a resource "{resource_name}" from '
f'".{os.path.sep}{resource.file[prefix_length:]}" but it '
f'was not imported for this contract.')
imported_resources = [r for r in program.resources.get(resource_name)
if r.interface == resource.interface]
for imported_resource in imported_resources:
if resource.file != imported_resource.file:
prefix_length = len(os.path.commonprefix([resource.file, imported_resource.file]))
resource_file = resource.file[prefix_length:]
imported_resource_file = imported_resource.file[prefix_length:]
raise InvalidProgramException(node, 'duplicate.resource',
f'There are two versions of the resource '
f'"{resource_name}" defined in an interface '
f'"{imported_resource.interface}" one from '
f'[...]"{imported_resource_file}" the other from '
f'[...]"{resource_file}".')
for interface_type in program.implements:
interface = program.interfaces[interface_type.name]
for resource_name, resource in program.declared_resources.items():
if resource_name in interface.own_resources:
raise InvalidProgramException(resource.node, 'duplicate.resource',
f'A contract cannot redeclare a resource it already imports. '
f'The resource "{resource_name}" got already declared in the '
f'interface {interface.name}.')
def _check_ghost_functions(program: VyperProgram):
if not isinstance(program, VyperInterface):
node = first(program.node.stmts) or program.node
for implemented_ghost in program.ghost_function_implementations.values():
if program.ghost_functions.get(implemented_ghost.name) is None:
raise InvalidProgramException(implemented_ghost.node, 'missing.ghost',
f'This contract is implementing an unknown ghost function. '
f'None of the interfaces, this contract implements, declares a ghost '
f'function "{implemented_ghost.name}".')
for interface in program.interfaces.values():
for ghost_function_list in interface.ghost_functions.values():
for ghost_function in ghost_function_list:
imported_ghost_functions = [ghost_func
for ghost_func in program.ghost_functions.get(ghost_function.name, [])
if ghost_func.file == ghost_function.file]
if not imported_ghost_functions:
prefix_length = len(os.path.commonprefix([ghost_function.file, program.file]))
raise InvalidProgramException(node, 'missing.ghost',
f'The interface "{interface.name}" '
f'needs a ghost function "{ghost_function.name}" from '
f'".{os.path.sep}{ghost_function.file[prefix_length:]}" but it '
f'was not imported for this contract.')
imported_ghost_functions = [ghost_func
for ghost_func in program.ghost_functions.get(ghost_function.name)
if ghost_func.interface == ghost_function.interface]
for imported_ghost_function in imported_ghost_functions:
if ghost_function.file != imported_ghost_function.file:
prefix_length = len(os.path.commonprefix(
[ghost_function.file, imported_ghost_function.file]))
ghost_function_file = ghost_function.file[prefix_length:]
imported_ghost_function_file = imported_ghost_function.file[prefix_length:]
raise InvalidProgramException(node, 'duplicate.ghost',
f'There are two versions of the ghost function '
f'"{ghost_function.name}" defined in an interface '
f'"{ghost_function.interface}" one from '
f'[...]"{imported_ghost_function_file}" the other from '
f'[...]"{ghost_function_file}".')
def _check_ghost_implements(program: VyperProgram):
def check(cond, node, ghost_name, interface_name):
if not cond:
raise InvalidProgramException(node, 'ghost.not.implemented',
f'The ghost function "{ghost_name}" from the interface "{interface_name}" '
f'has not been implemented correctly.')
ghost_function_implementations = dict(program.ghost_function_implementations)
for itype in program.implements:
interface = program.interfaces[itype.name]
for ghost in interface.own_ghost_functions.values():
implementation = ghost_function_implementations.pop(ghost.name, None)
check(implementation is not None, program.node, ghost.name, itype.name)
check(implementation.name == ghost.name, implementation.node, ghost.name, itype.name)
check(len(implementation.args) == len(ghost.args), implementation.node, ghost.name, itype.name)
check(implementation.type == ghost.type, implementation.node, ghost.name, itype.name)
if len(ghost_function_implementations) > 0:
raise InvalidProgramException(first(ghost_function_implementations.values()).node, 'invalid.ghost.implemented',
f'This contract implements some ghost functions that have no declaration in '
f'any of the implemented interfaces.\n'
f'(Ghost functions without declaration: {list(ghost_function_implementations)})') | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/analysis/symbol_checker.py | symbol_checker.py |
from itertools import zip_longest
from contextlib import contextmanager
from typing import Optional, Union, Dict, Iterable
from twovyper.utils import first_index, switch, first
from twovyper.ast import ast_nodes as ast, names, types
from twovyper.ast.arithmetic import Decimal
from twovyper.ast.types import (
TypeBuilder, VyperType, MapType, ArrayType, StringType, StructType, AnyStructType,
SelfType, ContractType, InterfaceType, TupleType
)
from twovyper.ast.nodes import VyperProgram, VyperFunction, GhostFunction, VyperInterface
from twovyper.ast.text import pprint
from twovyper.ast.visitors import NodeVisitor
from twovyper.exceptions import InvalidProgramException, UnsupportedException
from twovyper.vyper import is_compatible_version, select_version
def _check(condition: bool, node: ast.Node, reason_code: str, msg: Optional[str] = None):
if not condition:
raise InvalidProgramException(node, reason_code, msg)
class TypeAnnotator(NodeVisitor):
# The type annotator annotates all expression nodes with type information.
# It works by using the visitor pattern as follows:
# - Each expression that is visited returns a list of possible types for it (ordered by
# priority) and a list of nodes which will have that type, e.g., the literal 5 will return
# the types [int128, uint256, address] when visited, and itself as the only node.
# - Statements simply return None, as they don't have types.
# - Some operations, e.g., binary operations, have as their result type the same type
# as the input type. The 'combine' method combines the input type sets for that.
# - If the required type is known at some point, 'annotate_expected' can be called with
# the expected type as the argument. It then checks that the nodes of the expected type
# and annotates all nodes.
# - If any type can be used, 'annotate' can be called to annotate all nodes with the first
# type in the list, i.e., the type with the highest priority.
def __init__(self, program: VyperProgram):
type_map = {}
for name, struct in program.structs.items():
type_map[name] = struct.type
for name, contract in program.contracts.items():
type_map[name] = contract.type
for name, interface in program.interfaces.items():
type_map[name] = interface.type
self.type_builder = TypeBuilder(type_map)
self.program = program
self.current_func: Union[VyperFunction, None] = None
self.current_loops: Dict[str, ast.For] = {}
self_type = self.program.fields.type
# Contains the possible types a variable can have
self.known_variables = {
names.BLOCK: [types.BLOCK_TYPE],
names.CHAIN: [types.CHAIN_TYPE],
names.TX: [types.TX_TYPE],
names.MSG: [types.MSG_TYPE],
names.SELF: [types.VYPER_ADDRESS, self_type],
names.LOG: [None],
names.LEMMA: [None]
}
self.known_variables.update({interface: [None] for interface in program.interfaces.keys()})
self.variables = self.known_variables.copy()
self.undecided_nodes = False
self.type_resolver = TypeResolver()
@contextmanager
def _function_scope(self, func: Union[VyperFunction, GhostFunction]):
old_func = self.current_func
self.current_func = func
old_variables = self.variables.copy()
self.variables = self.known_variables.copy()
self.variables.update({k: [v.type] for k, v in func.args.items()})
yield
self.current_func = old_func
self.variables = old_variables
@contextmanager
def _quantified_vars_scope(self):
old_variables = self.variables.copy()
yield
self.variables = old_variables
@contextmanager
def _loop_scope(self):
current_loops = self.current_loops
yield
self.current_loops = current_loops
@property
def method_name(self):
return 'visit'
def check_number_of_arguments(self, node: Union[ast.FunctionCall, ast.ReceiverCall], *expected: int,
allowed_keywords: Iterable[str] = (), required_keywords: Iterable[str] = (),
resources: int = 0):
_check(len(node.args) in expected, node, 'invalid.no.args')
for kw in node.keywords:
_check(kw.name in allowed_keywords, node, 'invalid.no.args')
for kw in required_keywords:
_check(any(k.name == kw for k in node.keywords), node, 'invalid.no.args')
if resources > 0 and self.program.config.has_option(names.CONFIG_NO_DERIVED_WEI):
_check(node.resource is not None, node, 'invalid.resource',
'The derived wei resource got disabled and cannot be used.')
if isinstance(node, ast.FunctionCall) and node.resource:
if resources == 1:
cond = not isinstance(node.resource, ast.Exchange)
elif resources == 2:
cond = isinstance(node.resource, ast.Exchange)
else:
cond = False
_check(cond, node, 'invalid.no.resources')
def annotate_program(self):
for resources in self.program.resources.values():
for resource in resources:
if (isinstance(resource.type, types.DerivedResourceType)
and isinstance(resource.type.underlying_resource, types.UnknownResourceType)):
underlying_resource, args = self._annotate_resource(resource.underlying_resource)
resource.underlying_address = underlying_resource.own_address
underlying_resource.derived_resources.append(resource)
if len(args) != 0:
_check(False, args[0], 'invalid.derived.resource',
'The underlying resource type must be declared without arguments.')
resource.type.underlying_resource = underlying_resource.type
derived_resource_member_types = resource.type.member_types.values()
underlying_resource_member_types = underlying_resource.type.member_types.values()
_check(resource.file != underlying_resource.file, resource.node, 'invalid.derived.resource',
'A resource cannot be a derived resource from a resource of the same contract.')
_check(resource.underlying_address is not None, resource.node, 'invalid.derived.resource',
'The underlying resource of a derived resource must have an address specified.')
for derived_member_type, underlying_member_type \
in zip_longest(derived_resource_member_types, underlying_resource_member_types):
_check(derived_member_type == underlying_member_type, resource.node,
'invalid.derived.resource',
'Arguments of derived resource are not matching underlying resource.')
if not isinstance(self.program, VyperInterface):
# Set analysed flag to True for all resources
for resources in self.program.resources.values():
for resource in resources:
resource.analysed = True
for function in self.program.functions.values():
with self._function_scope(function):
for pre in function.preconditions:
self.annotate_expected(pre, types.VYPER_BOOL, resolve=True)
for performs in function.performs:
self.annotate(performs, resolve=True)
self.visit(function.node)
self.resolve_type(function.node)
for name, default in function.defaults.items():
if default:
self.annotate_expected(default, function.args[name].type, resolve=True)
for post in function.postconditions:
self.annotate_expected(post, types.VYPER_BOOL, resolve=True)
for check in function.checks:
self.annotate_expected(check, types.VYPER_BOOL, resolve=True)
for loop_invariants in function.loop_invariants.values():
for loop_invariant in loop_invariants:
self.annotate_expected(loop_invariant, types.VYPER_BOOL, resolve=True)
for lemma in self.program.lemmas.values():
with self._function_scope(lemma):
for stmt in lemma.node.body:
assert isinstance(stmt, ast.ExprStmt)
self.annotate_expected(stmt.value, types.VYPER_BOOL, resolve=True)
for name, default in lemma.defaults.items():
if default:
self.annotate_expected(default, lemma.args[name].type, resolve=True)
for pre in lemma.preconditions:
self.annotate_expected(pre, types.VYPER_BOOL, resolve=True)
for ghost_function in self.program.ghost_function_implementations.values():
assert isinstance(ghost_function, GhostFunction)
with self._function_scope(ghost_function):
expression_stmt = ghost_function.node.body[0]
assert isinstance(expression_stmt, ast.ExprStmt)
self.annotate_expected(expression_stmt.value, ghost_function.type.return_type, resolve=True)
for inv in self.program.invariants:
self.annotate_expected(inv, types.VYPER_BOOL, resolve=True)
for post in self.program.general_postconditions:
self.annotate_expected(post, types.VYPER_BOOL, resolve=True)
for post in self.program.transitive_postconditions:
self.annotate_expected(post, types.VYPER_BOOL, resolve=True)
for check in self.program.general_checks:
self.annotate_expected(check, types.VYPER_BOOL, resolve=True)
if isinstance(self.program, VyperInterface):
for caller_private in self.program.caller_private:
self.annotate(caller_private, resolve=True)
def resolve_type(self, node: ast.Node):
if self.undecided_nodes:
self.type_resolver.resolve_type(node)
self.undecided_nodes = False
def generic_visit(self, node: ast.Node, *args):
assert False
def pass_through(self, node1, node=None):
vyper_types, nodes = self.visit(node1)
if node is not None:
nodes.append(node)
return vyper_types, nodes
def combine(self, node1, node2, node=None, allowed=lambda t: True):
types1, nodes1 = self.visit(node1)
types2, nodes2 = self.visit(node2)
def is_array(t):
return isinstance(t, ArrayType) and not t.is_strict
def longest_array(matching, lst):
try:
arrays = [t for t in lst if is_array(t) and t.element_type == matching.element_type]
return max(arrays, key=lambda t: t.size)
except ValueError:
raise InvalidProgramException(node if node is not None else node2, 'wrong.type')
def intersect(l1, l2):
for e in l1:
if is_array(e):
yield longest_array(e, l2)
else:
for t in l2:
if types.matches(e, t):
yield e
elif types.matches(t, e):
yield t
intersection = list(filter(allowed, intersect(types1, types2)))
if not intersection:
raise InvalidProgramException(node if node is not None else node2, 'wrong.type')
else:
if node:
return intersection, [*nodes1, *nodes2, node]
else:
return intersection, [*nodes1, *nodes2]
def annotate(self, node1, node2=None, allowed=lambda t: True, resolve=False):
if node2 is None:
combined, nodes = self.visit(node1)
else:
combined, nodes = self.combine(node1, node2, allowed=allowed)
for node in nodes:
if len(combined) > 1:
self.undecided_nodes = True
node.type = combined
else:
node.type = combined[0]
if resolve:
self.resolve_type(node1)
if node2 is not None:
self.resolve_type(node2)
def annotate_expected(self, node, expected, orelse=None, resolve=False):
"""
Checks that node has type `expected` (or matches the predicate `expected`) or, if that isn't the case,
that is has type `orelse` (or matches the predicate `orelse`).
"""
tps, nodes = self.visit(node)
def annotate_nodes(t):
node.type = t
for n in nodes:
n.type = t
if resolve:
self.resolve_type(node)
if isinstance(expected, VyperType):
if any(types.matches(t, expected) for t in tps):
annotate_nodes(expected)
return
else:
for t in tps:
if expected(t):
annotate_nodes(t)
return
if orelse:
self.annotate_expected(node, orelse)
else:
raise InvalidProgramException(node, 'wrong.type')
def visit_FunctionDef(self, node: ast.FunctionDef):
for stmt in node.body:
self.visit(stmt)
def visit_Return(self, node: ast.Return):
if node.value:
# Interfaces are allowed to just have `pass` as a body instead of a correct return,
# therefore we don't check for the correct return type.
if self.program.is_interface():
self.annotate(node.value)
else:
self.annotate_expected(node.value, self.current_func.type.return_type)
def visit_Assign(self, node: ast.Assign):
self.annotate(node.target, node.value)
def visit_AugAssign(self, node: ast.AugAssign):
self.annotate(node.target, node.value, types.is_numeric)
def visit_AnnAssign(self, node: ast.AnnAssign):
# This is a variable declaration so we add it to the type map. Since Vyper
# doesn't allow shadowing, we can just override the previous value.
variable_name = node.target.id
variable_type = self.type_builder.build(node.annotation)
self.variables[variable_name] = [variable_type]
self.annotate_expected(node.target, variable_type)
if node.value:
self.annotate_expected(node.value, variable_type)
def visit_For(self, node: ast.For):
self.annotate_expected(node.iter, lambda t: isinstance(t, ArrayType))
# Add the loop variable to the type map
var_name = node.target.id
var_type = node.iter.type.element_type
self.variables[var_name] = [var_type]
self.annotate_expected(node.target, var_type)
with self._loop_scope():
self.current_loops[var_name] = node
# Visit loop invariants
for loop_inv in self.current_func.loop_invariants.get(node, []):
self.annotate_expected(loop_inv, types.VYPER_BOOL)
# Visit body
for stmt in node.body:
self.visit(stmt)
def visit_If(self, node: ast.If):
self.annotate_expected(node.test, types.VYPER_BOOL)
for stmt in node.body + node.orelse:
self.visit(stmt)
def visit_Raise(self, node: ast.Raise):
if node.msg:
if not (isinstance(node.msg, ast.Name) and node.msg.id == names.UNREACHABLE):
self.annotate(node.msg)
def visit_Assert(self, node: ast.Assert):
self.annotate_expected(node.test, types.VYPER_BOOL)
def visit_ExprStmt(self, node: ast.ExprStmt):
self.annotate(node.value)
def visit_Log(self, node: ast.Log):
_check(isinstance(node.body, ast.FunctionCall), node, 'invalid.log')
assert isinstance(node.body, ast.FunctionCall)
for arg in node.body.args:
self.annotate(arg)
for kw in node.body.keywords:
self.annotate(kw.value)
def visit_Pass(self, node: ast.Pass):
pass
def visit_Continue(self, node: ast.Continue):
pass
def visit_Break(self, node: ast.Break):
pass
def visit_BoolOp(self, node: ast.BoolOp):
self.annotate_expected(node.left, types.VYPER_BOOL)
self.annotate_expected(node.right, types.VYPER_BOOL)
return [types.VYPER_BOOL], [node]
def visit_Not(self, node: ast.Not):
self.annotate_expected(node.operand, types.VYPER_BOOL)
return [types.VYPER_BOOL], [node]
def visit_ArithmeticOp(self, node: ast.ArithmeticOp):
return self.combine(node.left, node.right, node, types.is_numeric)
def visit_UnaryArithmeticOp(self, node: ast.UnaryArithmeticOp):
return self.pass_through(node.operand, node)
def visit_IfExpr(self, node: ast.IfExpr):
self.annotate_expected(node.test, types.VYPER_BOOL)
return self.combine(node.body, node.orelse, node)
def visit_Comparison(self, node: ast.Comparison):
self.annotate(node.left, node.right)
return [types.VYPER_BOOL], [node]
def visit_Containment(self, node: ast.Containment):
self.annotate_expected(node.list, lambda t: isinstance(t, ArrayType))
array_type = node.list.type
assert isinstance(array_type, ArrayType)
self.annotate_expected(node.value, array_type.element_type)
return [types.VYPER_BOOL], [node]
def visit_Equality(self, node: ast.Equality):
self.annotate(node.left, node.right)
return [types.VYPER_BOOL], [node]
def visit_FunctionCall(self, node: ast.FunctionCall):
name = node.name
if node.resource:
self._visit_resource(node.resource, node)
with switch(name) as case:
if case(names.CONVERT):
self.check_number_of_arguments(node, 2)
self.annotate(node.args[0])
ntype = self.type_builder.build(node.args[1])
return [ntype], [node]
elif case(names.SUCCESS):
self.check_number_of_arguments(node, 0, 1, allowed_keywords=[names.SUCCESS_IF_NOT])
if node.args:
argument = node.args[0]
assert isinstance(argument, ast.ReceiverCall)
self.annotate(argument)
_check(isinstance(argument.receiver.type, types.SelfType), argument, 'spec.success',
'Only functions defined in this contract can be called from the specification.')
return [types.VYPER_BOOL], [node]
elif case(names.REVERT):
self.check_number_of_arguments(node, 0, 1)
if node.args:
argument = node.args[0]
assert isinstance(argument, ast.ReceiverCall)
self.annotate(argument)
_check(isinstance(argument.receiver.type, types.SelfType), argument, 'spec.success',
'Only functions defined in this contract can be called from the specification.')
return [types.VYPER_BOOL], [node]
elif case(names.FORALL):
return self._visit_forall(node)
elif case(names.ACCESSIBLE):
return self._visit_accessible(node)
elif case(names.EVENT):
self.check_number_of_arguments(node, 1, 2)
return self._visit_event(node)
elif case(names.PREVIOUS):
self.check_number_of_arguments(node, 1)
self.annotate(node.args[0])
loop = self._retrieve_loop(node, names.PREVIOUS)
loop_array_type = loop.iter.type
assert isinstance(loop_array_type, ArrayType)
return [ArrayType(loop_array_type.element_type, loop_array_type.size, False)], [node]
elif case(names.LOOP_ARRAY):
self.check_number_of_arguments(node, 1)
self.annotate(node.args[0])
loop = self._retrieve_loop(node, names.LOOP_ARRAY)
loop_array_type = loop.iter.type
assert isinstance(loop_array_type, ArrayType)
return [loop_array_type], [node]
elif case(names.LOOP_ITERATION):
self.check_number_of_arguments(node, 1)
self.annotate(node.args[0])
self._retrieve_loop(node, names.LOOP_ITERATION)
return [types.VYPER_UINT256], [node]
elif case(names.CALLER):
self.check_number_of_arguments(node, 0)
return [types.VYPER_ADDRESS], [node]
elif case(names.RANGE):
self.check_number_of_arguments(node, 1, 2)
return self._visit_range(node)
elif case(names.MIN) or case(names.MAX):
self.check_number_of_arguments(node, 2)
return self.combine(node.args[0], node.args[1], node, types.is_numeric)
elif case(names.ADDMOD) or case(names.MULMOD):
self.check_number_of_arguments(node, 3)
for arg in node.args:
self.annotate_expected(arg, types.VYPER_UINT256)
return [types.VYPER_UINT256], [node]
elif case(names.SQRT):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_DECIMAL)
return [types.VYPER_DECIMAL], [node]
elif case(names.SHIFT):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_UINT256)
self.annotate_expected(node.args[1], types.VYPER_INT128)
elif case(names.BITWISE_NOT):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_UINT256)
return [types.VYPER_UINT256], [node]
elif case(names.BITWISE_AND) or case(names.BITWISE_OR) or case(names.BITWISE_XOR):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_UINT256)
self.annotate_expected(node.args[1], types.VYPER_UINT256)
return [types.VYPER_UINT256], [node]
elif case(names.OLD) or case(names.PUBLIC_OLD) or case(names.ISSUED):
self.check_number_of_arguments(node, 1)
return self.pass_through(node.args[0], node)
elif case(names.INDEPENDENT):
self.check_number_of_arguments(node, 2)
self.annotate(node.args[0])
self.annotate(node.args[1])
return [types.VYPER_BOOL], [node]
elif case(names.REORDER_INDEPENDENT):
self.check_number_of_arguments(node, 1)
self.annotate(node.args[0])
return [types.VYPER_BOOL], [node]
elif case(names.FLOOR) or case(names.CEIL):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_DECIMAL)
return [types.VYPER_INT128], [node]
elif case(names.LEN):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], lambda t: isinstance(t, types.ArrayType))
return_type = select_version({'^0.2.0': types.VYPER_UINT256,
'>=0.1.0-beta.16 <0.1.0': types.VYPER_INT128})
return [return_type], [node]
elif case(names.STORAGE):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
# We know that storage(self) has the self-type
first_arg = node.args[0]
if isinstance(first_arg, ast.Name) and first_arg.id == names.SELF:
return [self.program.type, AnyStructType()], [node]
# Otherwise it is just some struct, which we don't know anything about
else:
return [AnyStructType()], [node]
elif case(names.ASSERT_MODIFIABLE):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_BOOL)
return [None], [node]
elif case(names.SEND):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
return [None], [node]
elif case(names.SELFDESTRUCT):
self.check_number_of_arguments(node, 0, 1)
if node.args:
# The selfdestruct Vyper function
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [None], [node]
else:
# The selfdestruct verification function
return [types.VYPER_BOOL], [node]
elif case(names.CLEAR):
# Not type checking is needed here as clear may only occur in actual Vyper code
self.annotate(node.args[0])
return [None], [node]
elif case(names.RAW_CALL):
# No type checking is needed here as raw_call may only occur in actual Vyper code
for arg in node.args:
self.annotate(arg)
for kwarg in node.keywords:
self.annotate(kwarg.value)
idx = first_index(lambda n: n.name == names.RAW_CALL_OUTSIZE, node.keywords)
outsize_arg = node.keywords[idx].value
assert isinstance(outsize_arg, ast.Num)
size = outsize_arg.n
return [ArrayType(types.VYPER_BYTE, size, False)], [node]
elif case(names.RAW_LOG):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], ArrayType(types.VYPER_BYTES32, 4, False))
self.annotate_expected(node.args[1], types.is_bytes_array)
return [None], [node]
elif case(names.CREATE_FORWARDER_TO):
self.check_number_of_arguments(node, 1, allowed_keywords=[names.CREATE_FORWARDER_TO_VALUE])
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
if node.keywords:
self.annotate_expected(node.keywords[0].value, types.VYPER_WEI_VALUE)
return [types.VYPER_ADDRESS], [node]
elif case(names.AS_WEI_VALUE):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.is_integer)
unit = node.args[1]
_check(isinstance(unit, ast.Str) and
# Check that the unit exists
next((v for k, v in names.ETHER_UNITS.items() if unit.s in k), False),
node, 'invalid.unit')
return [types.VYPER_WEI_VALUE], [node]
elif case(names.AS_UNITLESS_NUMBER):
self.check_number_of_arguments(node, 1)
# We ignore units completely, therefore the type stays the same
return self.pass_through(node.args[0], node)
elif case(names.EXTRACT32):
self.check_number_of_arguments(node, 2, allowed_keywords=[names.EXTRACT32_TYPE])
self.annotate_expected(node.args[0], types.is_bytes_array)
self.annotate_expected(node.args[1], types.VYPER_INT128)
return_type = self.type_builder.build(node.keywords[0].value) if node.keywords else types.VYPER_BYTES32
return [return_type], [node]
elif case(names.CONCAT):
_check(bool(node.args), node, 'invalid.no.args')
for arg in node.args:
self.annotate_expected(arg, types.is_bytes_array)
size = sum(arg.type.size for arg in node.args)
return [ArrayType(node.args[0].type.element_type, size, False)], [node]
elif case(names.KECCAK256) or case(names.SHA256):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.is_bytes_array)
return [types.VYPER_BYTES32], [node]
elif case(names.BLOCKHASH):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_UINT256)
return [types.VYPER_BYTES32], [node]
elif case(names.METHOD_ID):
if is_compatible_version('>=0.1.0-beta.16 <0.1.0'):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], lambda t: isinstance(t, StringType))
ntype = self.type_builder.build(node.args[1])
elif is_compatible_version('^0.2.0'):
self.check_number_of_arguments(node, 1, allowed_keywords=[names.METHOD_ID_OUTPUT_TYPE])
self.annotate_expected(node.args[0], lambda t: isinstance(t, StringType))
ntype = types.ArrayType(types.VYPER_BYTE, 4)
for keyword in node.keywords:
if keyword.name == names.METHOD_ID_OUTPUT_TYPE:
ntype = self.type_builder.build(keyword.value)
else:
assert False
is_bytes32 = ntype == types.VYPER_BYTES32
is_bytes4 = (isinstance(ntype, ArrayType) and ntype.element_type == types.VYPER_BYTE
and ntype.size == 4)
_check(is_bytes32 or is_bytes4, node, 'invalid.method_id')
return [ntype], [node]
elif case(names.ECRECOVER):
self.check_number_of_arguments(node, 4)
self.annotate_expected(node.args[0], types.VYPER_BYTES32)
self.annotate_expected(node.args[1], types.VYPER_UINT256)
self.annotate_expected(node.args[2], types.VYPER_UINT256)
self.annotate_expected(node.args[3], types.VYPER_UINT256)
return [types.VYPER_ADDRESS], [node]
elif case(names.ECADD) or case(names.ECMUL):
self.check_number_of_arguments(node, 2)
int_pair = ArrayType(types.VYPER_UINT256, 2)
self.annotate_expected(node.args[0], int_pair)
arg_type = int_pair if case(names.ECADD) else types.VYPER_UINT256
self.annotate_expected(node.args[1], arg_type)
return [int_pair], [node]
elif case(names.EMPTY):
self.check_number_of_arguments(node, 1)
ntype = self.type_builder.build(node.args[0])
return [ntype], [node]
elif case(names.IMPLIES):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_BOOL)
self.annotate_expected(node.args[1], types.VYPER_BOOL)
return [types.VYPER_BOOL], [node]
elif case(names.RESULT):
self.check_number_of_arguments(node, 0, 1, allowed_keywords=[names.RESULT_DEFAULT])
if node.args:
argument = node.args[0]
_check(isinstance(argument, ast.ReceiverCall), argument, 'spec.result',
'Only functions defined in this contract can be called from the specification.')
assert isinstance(argument, ast.ReceiverCall)
self.annotate(argument)
_check(isinstance(argument.receiver.type, types.SelfType), argument, 'spec.result',
'Only functions defined in this contract can be called from the specification.')
func = self.program.functions[argument.name]
for kw in node.keywords:
self.annotate_expected(kw.value, func.type.return_type)
return [func.type.return_type], [node]
elif len(node.keywords) > 0:
_check(False, node.keywords[0].value, 'spec.result',
'The default keyword argument can only be used in combination with a pure function.')
return [self.current_func.type.return_type], [node]
elif case(names.SUM):
self.check_number_of_arguments(node, 1)
def is_numeric_map_or_array(t):
return isinstance(t, types.MapType) and types.is_numeric(t.value_type) \
or isinstance(t, types.ArrayType) and types.is_numeric(t.element_type)
self.annotate_expected(node.args[0], is_numeric_map_or_array)
if isinstance(node.args[0].type, types.MapType):
vyper_type = node.args[0].type.value_type
elif isinstance(node.args[0].type, types.ArrayType):
vyper_type = node.args[0].type.element_type
else:
assert False
return [vyper_type], [node]
elif case(names.TUPLE):
return self._visit_tuple(node.args), [node]
elif case(names.SENT) or case(names.RECEIVED) or case(names.ALLOCATED):
self.check_number_of_arguments(node, 0, 1, resources=1 if case(names.ALLOCATED) else 0)
if not node.args:
map_type = types.MapType(types.VYPER_ADDRESS, types.NON_NEGATIVE_INT)
return [map_type], [node]
else:
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [types.NON_NEGATIVE_INT], [node]
elif case(names.LOCKED):
self.check_number_of_arguments(node, 1)
lock = node.args[0]
_check(isinstance(lock, ast.Str) and lock.s in self.program.nonreentrant_keys(), node, 'invalid.lock')
return [types.VYPER_BOOL], [node]
elif case(names.OVERFLOW) or case(names.OUT_OF_GAS):
self.check_number_of_arguments(node, 0)
return [types.VYPER_BOOL], [node]
elif case(names.FAILED):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [types.VYPER_BOOL], [node]
elif case(names.IMPLEMENTS):
self.check_number_of_arguments(node, 2)
address = node.args[0]
interface = node.args[1]
is_interface = (isinstance(interface, ast.Name)
and (interface.id in self.program.interfaces
or isinstance(self.program, VyperInterface) and interface.id == self.program.name))
_check(is_interface, node, 'invalid.interface')
self.annotate_expected(address, types.VYPER_ADDRESS)
return [types.VYPER_BOOL], [node]
elif case(names.INTERPRETED):
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_BOOL)
return [types.VYPER_BOOL], [node]
elif case(names.CONDITIONAL):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_BOOL)
return self.pass_through(node.args[1], node)
elif case(names.REALLOCATE):
keywords = [names.REALLOCATE_TO, names.REALLOCATE_ACTOR]
required = [names.REALLOCATE_TO]
self.check_number_of_arguments(node, 1, allowed_keywords=keywords,
required_keywords=required, resources=1)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.keywords[0].value, types.VYPER_ADDRESS)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [None], [node]
elif case(names.FOREACH):
return self._visit_foreach(node)
elif case(names.OFFER):
keywords = {
names.OFFER_TO: types.VYPER_ADDRESS,
names.OFFER_ACTOR: types.VYPER_ADDRESS,
names.OFFER_TIMES: types.VYPER_UINT256
}
required = [names.OFFER_TO, names.OFFER_TIMES]
self.check_number_of_arguments(node, 2, allowed_keywords=keywords.keys(),
required_keywords=required, resources=2)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
for kw in node.keywords:
self.annotate_expected(kw.value, keywords[kw.name])
return [None], [node]
elif case(names.ALLOW_TO_DECOMPOSE):
self.check_number_of_arguments(node, 2, resources=1)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[1], types.VYPER_ADDRESS)
return [None], [node]
elif case(names.REVOKE):
keywords = {
names.REVOKE_TO: types.VYPER_ADDRESS,
names.REVOKE_ACTOR: types.VYPER_ADDRESS
}
required = [names.REVOKE_TO]
self.check_number_of_arguments(node, 2, allowed_keywords=keywords.keys(),
required_keywords=required, resources=2)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
for kw in node.keywords:
self.annotate_expected(kw.value, keywords[kw.name])
return [None], [node]
elif case(names.EXCHANGE):
keywords = [names.EXCHANGE_TIMES]
self.check_number_of_arguments(node, 4, allowed_keywords=keywords,
required_keywords=keywords, resources=2)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[2], types.VYPER_ADDRESS)
self.annotate_expected(node.args[3], types.VYPER_ADDRESS)
self.annotate_expected(node.keywords[0].value, types.VYPER_UINT256)
return [None], [node]
elif case(names.CREATE):
keywords = {
names.CREATE_TO: types.VYPER_ADDRESS,
names.CREATE_ACTOR: types.VYPER_ADDRESS
}
self.check_number_of_arguments(node, 1, allowed_keywords=keywords.keys(), resources=1)
_check(node.resource is not None and node.underlying_resource is None, node, 'invalid.create',
'Only non-derived resources can be used with "create"')
self.annotate_expected(node.args[0], types.VYPER_UINT256)
for kw in node.keywords:
self.annotate_expected(kw.value, keywords[kw.name])
return [None], [node]
elif case(names.DESTROY):
keywords = [names.DESTROY_ACTOR]
self.check_number_of_arguments(node, 1, resources=1, allowed_keywords=keywords)
_check(node.resource is not None and node.underlying_resource is None, node, 'invalid.destroy',
'Only non-derived resources can be used with "destroy"')
self.annotate_expected(node.args[0], types.VYPER_UINT256)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [None], [node]
elif case(names.RESOURCE_PAYABLE):
keywords = [names.RESOURCE_PAYABLE_ACTOR]
self.check_number_of_arguments(node, 1, resources=1, allowed_keywords=keywords)
_check(node.resource is None or node.underlying_resource is not None, node, 'invalid.payable',
'Only derived resources can be used with "payable"')
self.annotate_expected(node.args[0], types.VYPER_UINT256)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [None], [node]
elif case(names.RESOURCE_PAYOUT):
keywords = [names.RESOURCE_PAYOUT_ACTOR]
self.check_number_of_arguments(node, 1, resources=1, allowed_keywords=keywords)
_check(node.resource is None or node.underlying_resource is not None, node, 'invalid.payout',
'Only derived resources can be used with "payout"')
self.annotate_expected(node.args[0], types.VYPER_UINT256)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [None], [node]
elif case(names.TRUST):
keywords = [names.TRUST_ACTOR]
self.check_number_of_arguments(node, 2, allowed_keywords=keywords)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
self.annotate_expected(node.args[1], types.VYPER_BOOL)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [None], [node]
elif case(names.ALLOCATE_UNTRACKED):
self.check_number_of_arguments(node, 1, resources=0) # By setting resources to 0 we only allow wei.
_check(node.resource is None or node.underlying_resource is not None, node,
'invalid.allocate_untracked', 'Only derived resources can be used with "allocate_untracked"')
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [None], [node]
elif case(names.OFFERED):
self.check_number_of_arguments(node, 4, resources=2)
self.annotate_expected(node.args[0], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
self.annotate_expected(node.args[2], types.VYPER_ADDRESS)
self.annotate_expected(node.args[3], types.VYPER_ADDRESS)
return [types.NON_NEGATIVE_INT], [node]
elif case(names.NO_OFFERS):
self.check_number_of_arguments(node, 1, resources=1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [types.VYPER_BOOL], [node]
elif case(names.ALLOWED_TO_DECOMPOSE):
self.check_number_of_arguments(node, 1, resources=1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [types.VYPER_UINT256], [node]
elif case(names.TRUSTED):
keywords = [names.TRUSTED_BY, names.TRUSTED_WHERE]
required_keywords = [names.TRUSTED_BY]
self.check_number_of_arguments(node, 1, allowed_keywords=keywords, required_keywords=required_keywords)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
for kw in node.keywords:
self.annotate_expected(kw.value, types.VYPER_ADDRESS)
return [types.VYPER_BOOL], [node]
elif case(names.TRUST_NO_ONE):
self.check_number_of_arguments(node, 2)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
self.annotate_expected(node.args[1], types.VYPER_ADDRESS)
return [types.VYPER_BOOL], [node]
elif len(node.args) == 1 and isinstance(node.args[0], ast.Dict):
# This is a struct initializer
self.check_number_of_arguments(node, 1)
return self._visit_struct_init(node)
elif name in self.program.contracts:
# This is a contract initializer
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [self.program.contracts[name].type], [node]
elif name in self.program.interfaces:
# This is an interface initializer
self.check_number_of_arguments(node, 1)
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
return [self.program.interfaces[name].type], [node]
elif name in self.program.ghost_functions:
possible_functions = self.program.ghost_functions[name]
if len(possible_functions) != 1:
if isinstance(self.program, VyperInterface):
function = [fun for fun in possible_functions if fun.file == self.program.file][0]
else:
implemented_interfaces = [self.program.interfaces[i.name].file for i in self.program.implements]
function = [fun for fun in possible_functions if fun.file in implemented_interfaces][0]
else:
function = possible_functions[0]
self.check_number_of_arguments(node, len(function.args) + 1)
arg_types = [types.VYPER_ADDRESS, *[arg.type for arg in function.args.values()]]
for arg_type, arg in zip(arg_types, node.args):
self.annotate_expected(arg, arg_type)
return [function.type.return_type], [node]
else:
raise UnsupportedException(node, "Unsupported function call")
def visit_ReceiverCall(self, node: ast.ReceiverCall):
receiver = node.receiver
if isinstance(receiver, ast.Name):
# A lemma call
if receiver.id == names.LEMMA:
self.annotate(receiver)
_check(not isinstance(receiver.type, (ContractType, InterfaceType)),
receiver, 'invalid.lemma.receiver',
'A receiver, with name "lemma" and with a contract- or interface-type, is not supported.')
lemma = self.program.lemmas[node.name]
self.check_number_of_arguments(node, len(lemma.args))
for arg, func_arg in zip(node.args, lemma.args.values()):
self.annotate_expected(arg, func_arg.type)
return [types.VYPER_BOOL], [node]
# A receiver ghost function call
elif receiver.id in self.program.interfaces.keys():
self.annotate(receiver)
function = self.program.interfaces[receiver.id].own_ghost_functions[node.name]
self.check_number_of_arguments(node, len(function.args) + 1)
arg_types = [types.VYPER_ADDRESS, *[arg.type for arg in function.args.values()]]
for arg_type, arg in zip(arg_types, node.args):
self.annotate_expected(arg, arg_type)
return [function.type.return_type], [node]
def expected(t):
is_self_call = isinstance(t, SelfType)
is_external_call = isinstance(t, (ContractType, InterfaceType))
is_log = t is None
return is_self_call or is_external_call or is_log
self.annotate_expected(receiver, expected)
receiver_type = receiver.type
# A self call
if isinstance(receiver_type, SelfType):
function = self.program.functions[node.name]
num_args = len(function.args)
num_defaults = len(function.defaults)
self.check_number_of_arguments(node, *range(num_args - num_defaults, num_args + 1))
for arg, func_arg in zip(node.args, function.args.values()):
self.annotate_expected(arg, func_arg.type)
return [function.type.return_type], [node]
else:
for arg in node.args:
self.annotate(arg)
for kw in node.keywords:
self.annotate(kw.value)
# A logging call
if not receiver_type:
return [None], [node]
# A contract call
elif isinstance(receiver_type, ContractType):
return [receiver_type.function_types[node.name].return_type], [node]
elif isinstance(receiver_type, InterfaceType):
interface = self.program.interfaces[receiver_type.name]
function = interface.functions[node.name]
return [function.type.return_type], [node]
else:
assert False
def _visit_resource_address(self, node: ast.Node, resource_name: str, interface: Optional[VyperInterface] = None):
self.annotate_expected(node, types.VYPER_ADDRESS)
_check(resource_name != names.UNDERLYING_WEI, node, 'invalid.resource.address',
'The underlying wei resource cannot have an address.')
is_wei = resource_name == names.WEI
ref_interface = None
if isinstance(node, ast.Name):
ref_interface = self.program
elif isinstance(node, ast.Attribute):
for field, field_type in self.program.fields.type.member_types.items():
if node.attr == field:
_check(isinstance(field_type, types.InterfaceType), node, 'invalid.resource.address')
assert isinstance(field_type, types.InterfaceType)
ref_interface = self.program.interfaces[field_type.name]
_check(is_wei or resource_name in ref_interface.own_resources, node, 'invalid.resource.address')
break
else:
_check(False, node, 'invalid.resource.address')
elif isinstance(node, ast.FunctionCall):
if node.name in self.program.ghost_functions:
if isinstance(self.program, VyperInterface):
function = self.program.ghost_functions[node.name][0]
else:
function = self.program.ghost_function_implementations.get(node.name)
if function is None:
function = self.program.ghost_functions[node.name][0]
_check(isinstance(function.type.return_type, types.InterfaceType), node, 'invalid.resource.address')
assert isinstance(function.type.return_type, types.InterfaceType)
program = first(interface for interface in self.program.interfaces.values()
if interface.file == function.file) or self.program
ref_interface = program.interfaces[function.type.return_type.name]
else:
self.check_number_of_arguments(node, 1)
ref_interface = self.program.interfaces[node.name]
_check(is_wei or resource_name in ref_interface.own_resources, node, 'invalid.resource.address')
elif isinstance(node, ast.ReceiverCall):
assert node.name in self.program.ghost_functions
assert isinstance(node.receiver, ast.Name)
interface_name = node.receiver.id
function = self.program.interfaces[interface_name].own_ghost_functions.get(node.name)
_check(isinstance(function.type.return_type, types.InterfaceType), node, 'invalid.resource.address')
assert isinstance(function.type.return_type, types.InterfaceType)
program = first(interface for interface in self.program.interfaces.values()
if interface.file == function.file) or self.program
ref_interface = program.interfaces[function.type.return_type.name]
_check(is_wei or resource_name in ref_interface.own_resources, node, 'invalid.resource.address')
else:
assert False
if not is_wei and ref_interface is not None:
if interface is not None:
if isinstance(ref_interface, VyperInterface):
_check(ref_interface.file == interface.file, node, 'invalid.resource.address')
else:
interface_names = [t.name for t in ref_interface.implements]
interfaces = [ref_interface.interfaces[name] for name in interface_names]
files = [ref_interface.file] + [i.file for i in interfaces]
_check(interface.file in files, node, 'invalid.resource.address')
elif isinstance(ref_interface, VyperInterface):
self_is_interface = isinstance(self.program, VyperInterface)
self_does_not_have_resource = resource_name not in self.program.own_resources
_check(self_is_interface or self_does_not_have_resource, node, 'invalid.resource.address')
def _annotate_resource(self, node: ast.Node, top: bool = False):
if isinstance(node, ast.Name):
resources = self.program.resources.get(node.id)
if resources is not None and len(resources) == 1:
resource = resources[0]
if self.program.config.has_option(names.CONFIG_NO_DERIVED_WEI):
_check(resource.name != names.WEI, node, 'invalid.resource')
if (top and self.program.file != resource.file
and resource.name != names.WEI
and resource.name != names.UNDERLYING_WEI):
interface = first(i for i in self.program.interfaces.values() if i.file == resource.file)
_check(any(i.name == interface.name for i in self.program.implements), node, 'invalid.resource')
_check(node.id in interface.declared_resources, node, 'invalid.resource')
else:
resource = self.program.declared_resources.get(node.id)
args = []
elif isinstance(node, ast.FunctionCall) and node.name == names.CREATOR:
resource, args = self._annotate_resource(node.args[0])
node.type = node.args[0].type
elif isinstance(node, ast.FunctionCall):
resources = self.program.resources.get(node.name)
if resources is not None and len(resources) == 1:
resource = resources[0]
else:
resource = self.program.declared_resources.get(node.name)
if self.program.config.has_option(names.CONFIG_NO_DERIVED_WEI):
_check(resource.name != names.WEI, node, 'invalid.resource')
if node.resource is not None:
assert isinstance(node.resource, ast.Expr)
self._visit_resource_address(node.resource, node.name)
resource.own_address = node.resource
elif (top and self.program.file != resource.file
and resource.name != names.WEI
and resource.name != names.UNDERLYING_WEI):
interface = first(i for i in self.program.interfaces.values() if i.file == resource.file)
_check(any(i.name == interface.name for i in self.program.implements), node, 'invalid.resource')
_check(node.name in interface.declared_resources, node, 'invalid.resource')
args = node.args
elif isinstance(node, ast.Attribute):
assert isinstance(node.value, ast.Name)
interface = self.program.interfaces[node.value.id]
if top:
_check(any(i.name == interface.name for i in self.program.implements), node, 'invalid.resource')
_check(node.attr in interface.declared_resources, node, 'invalid.resource')
resource = interface.declared_resources.get(node.attr)
args = []
elif isinstance(node, ast.ReceiverCall):
address = None
if isinstance(node.receiver, ast.Name):
interface = self.program.interfaces[node.receiver.id]
if top:
_check(any(i.name == interface.name for i in self.program.implements), node, 'invalid.resource')
_check(node.name in interface.declared_resources, node, 'invalid.resource')
elif isinstance(node.receiver, ast.Subscript):
assert isinstance(node.receiver.value, ast.Attribute)
assert isinstance(node.receiver.value.value, ast.Name)
interface_name = node.receiver.value.value.id
interface = self.program.interfaces[interface_name]
if top:
_check(node.name in interface.declared_resources, node, 'invalid.resource')
address = node.receiver.index
self._visit_resource_address(address, node.name, interface)
else:
assert False
resource = interface.declared_resources.get(node.name)
resource.own_address = address
args = node.args
elif isinstance(node, ast.Subscript):
address = node.index
resource, args = self._annotate_resource(node.value)
node.type = node.value.type
interface = None
if isinstance(node.value, ast.Name):
resource_name = node.value.id
elif isinstance(node.value, ast.Attribute):
assert isinstance(node.value.value, ast.Name)
interface = self.program.interfaces[node.value.value.id]
resource_name = node.value.attr
_check(resource_name in interface.declared_resources, node, 'invalid.resource')
else:
assert False
self._visit_resource_address(address, resource_name, interface)
resource.own_address = address
else:
assert False
if not resource:
raise InvalidProgramException(node, 'invalid.resource',
f'Could not find a resource for node:\n{pprint(node, True)}')
for arg_type, arg in zip(resource.type.member_types.values(), args):
self.annotate_expected(arg, arg_type)
node.type = resource.type
return resource, args
def _visit_resource(self, node: ast.Node, top_node: Optional[ast.FunctionCall] = None):
if isinstance(node, ast.Exchange):
self._visit_resource(node.left, top_node)
self._visit_resource(node.right, top_node)
return
resource, args = self._annotate_resource(node, True)
if len(args) != len(resource.type.member_types):
raise InvalidProgramException(node, 'invalid.resource')
if top_node is not None and top_node.underlying_resource is None:
top_node.underlying_resource = resource.underlying_resource
def _add_quantified_vars(self, var_decls: ast.Dict):
vars_types = zip(var_decls.keys, var_decls.values)
for name, type_annotation in vars_types:
var_type = self.type_builder.build(type_annotation)
self.variables[name.id] = [var_type]
name.type = var_type
def _visit_forall(self, node: ast.FunctionCall):
with self._quantified_vars_scope():
# Add the quantified variables {<x1>: <t1>, <x2>: <t2>, ...} to the
# variable map
first_arg = node.args[0]
assert isinstance(first_arg, ast.Dict)
self._add_quantified_vars(first_arg)
# Triggers can have any type
for arg in node.args[1:-1]:
self.annotate(arg)
# The quantified expression is always a Boolean
self.annotate_expected(node.args[-1], types.VYPER_BOOL)
return [types.VYPER_BOOL], [node]
def _visit_foreach(self, node: ast.FunctionCall):
with self._quantified_vars_scope():
# Add the quantified variables {<x1>: <t1>, <x2>: <t2>, ...} to the
# variable map
first_arg = node.args[0]
assert isinstance(first_arg, ast.Dict)
self._add_quantified_vars(first_arg)
# Triggers can have any type
for arg in node.args[1:-1]:
self.annotate(arg)
# Annotate the body
self.annotate(node.args[-1])
return [None], [node]
def _visit_accessible(self, node: ast.FunctionCall):
self.annotate_expected(node.args[0], types.VYPER_ADDRESS)
self.annotate_expected(node.args[1], types.VYPER_WEI_VALUE)
if len(node.args) == 3:
function_call = node.args[2]
assert isinstance(function_call, ast.ReceiverCall)
function = self.program.functions[function_call.name]
for arg, arg_type in zip(function_call.args, function.type.arg_types):
self.annotate_expected(arg, arg_type)
return [types.VYPER_BOOL], [node]
def _visit_event(self, node: ast.FunctionCall):
event = node.args[0]
assert isinstance(event, ast.FunctionCall)
event_name = event.name
event_type = self.program.events[event_name].type
for arg, arg_type in zip(event.args, event_type.arg_types):
self.annotate_expected(arg, arg_type)
if len(node.args) == 2:
self.annotate_expected(node.args[1], types.VYPER_UINT256)
return [types.VYPER_BOOL], [node]
def _visit_struct_init(self, node: ast.FunctionCall):
ntype = self.program.structs[node.name].type
struct_dict = node.args[0]
assert isinstance(struct_dict, ast.Dict)
for key, value in zip(struct_dict.keys, struct_dict.values):
value_type = ntype.member_types[key.id]
self.annotate_expected(value, value_type)
return [ntype], [node]
def _visit_range(self, node: ast.FunctionCall):
_check(len(node.args) > 0, node, 'invalid.range')
first_arg = node.args[0]
self.annotate_expected(first_arg, types.is_integer)
if len(node.args) == 1:
# A range expression of the form 'range(n)' where 'n' is a constant
assert isinstance(first_arg, ast.Num)
size = first_arg.n
elif len(node.args) == 2:
second_arg = node.args[1]
self.annotate_expected(second_arg, types.is_integer)
if isinstance(second_arg, ast.ArithmeticOp) \
and second_arg.op == ast.ArithmeticOperator.ADD \
and ast.compare_nodes(first_arg, second_arg.left):
assert isinstance(second_arg.right, ast.Num)
# A range expression of the form 'range(x, x + n)' where 'n' is a constant
size = second_arg.right.n
else:
assert isinstance(first_arg, ast.Num) and isinstance(second_arg, ast.Num)
# A range expression of the form 'range(n1, n2)' where 'n1' and 'n2 are constants
size = second_arg.n - first_arg.n
else:
raise InvalidProgramException(node, 'invalid.range')
_check(size > 0, node, 'invalid.range', 'The size of a range(...) must be greater than zero.')
return [ArrayType(types.VYPER_INT128, size, True)], [node]
def _retrieve_loop(self, node, name):
loop_var_name = node.args[0].id
loop = self.current_loops.get(loop_var_name)
_check(loop is not None, node, f"invalid.{name}")
return loop
@staticmethod
def visit_Bytes(node: ast.Bytes):
# Bytes could either be non-strict or (if it has length 32) strict
non_strict = types.ArrayType(types.VYPER_BYTE, len(node.s), False)
if len(node.s) == 32:
return [non_strict, types.VYPER_BYTES32], [node]
else:
return [non_strict], [node]
@staticmethod
def visit_Str(node: ast.Str):
string_bytes = bytes(node.s, 'utf-8')
ntype = StringType(len(string_bytes))
return [ntype], [node]
# Sets occur in trigger expressions
def visit_Set(self, node: ast.Set):
for elem in node.elements:
# Triggers can have any type
self.annotate(elem)
return [None], [node]
@staticmethod
def visit_Num(node: ast.Num):
if isinstance(node.n, int):
max_int128 = 2 ** 127 - 1
max_address = 2 ** 160 - 1
if 0 <= node.n <= max_int128:
tps = [types.VYPER_INT128,
types.VYPER_UINT256,
types.VYPER_ADDRESS,
types.VYPER_BYTES32]
elif max_int128 < node.n <= max_address:
tps = [types.VYPER_UINT256,
types.VYPER_ADDRESS,
types.VYPER_BYTES32]
elif max_address < node.n:
tps = [types.VYPER_UINT256,
types.VYPER_BYTES32]
else:
tps = [types.VYPER_INT128]
nodes = [node]
return tps, nodes
elif isinstance(node.n, Decimal):
return [types.VYPER_DECIMAL], [node]
else:
assert False
@staticmethod
def visit_Bool(node: ast.Bool):
return [types.VYPER_BOOL], [node]
def visit_Attribute(self, node: ast.Attribute):
self.annotate_expected(node.value, lambda t: isinstance(t, StructType), types.VYPER_ADDRESS)
struct_type = node.value.type if isinstance(node.value.type, StructType) else types.AddressType()
ntype = struct_type.member_types.get(node.attr)
if not ntype:
raise InvalidProgramException(node, 'invalid.storage.var')
return [ntype], [node]
def visit_Subscript(self, node: ast.Subscript):
self.annotate_expected(node.value, lambda t: isinstance(t, (ArrayType, MapType)))
if isinstance(node.value.type, MapType):
key_type = node.value.type.key_type
self.annotate_expected(node.index, key_type)
ntype = node.value.type.value_type
elif isinstance(node.value.type, ArrayType):
self.annotate_expected(node.index, types.is_integer)
ntype = node.value.type.element_type
else:
assert False
return [ntype], [node]
def visit_Name(self, node: ast.Name):
_check(node.id in self.variables, node, 'invalid.local.var')
return self.variables[node.id], [node]
def visit_List(self, node: ast.List):
# Vyper guarantees that size > 0
size = len(node.elements)
for e in node.elements:
self.annotate(e)
element_types = [e.type for e in node.elements]
possible_types = []
for element_type in element_types:
if isinstance(element_type, list):
if possible_types:
possible_types = [t for t in possible_types if t in element_type]
else:
possible_types = element_type
else:
_check(not possible_types or element_type in possible_types, node, 'invalid.element.types')
possible_types = [element_type]
break
return [types.ArrayType(element_type, size) for element_type in possible_types], [node]
def visit_Tuple(self, node: ast.Tuple):
return self._visit_tuple(node.elements), [node]
def _visit_tuple(self, elements):
length = len(elements)
for e in elements:
self.annotate(e)
element_types = [e.type if isinstance(e.type, list) else [e.type] for e in elements]
sizes = [len(element_type) for element_type in element_types]
index = [0] * length
possible_types = []
while True:
possible_type = TupleType([element_types[i][index[i]] for i in range(length)])
possible_types.append(possible_type)
for i in range(length):
index[i] = (index[i] + 1) % sizes[i]
if index[i]:
break
else:
break
return possible_types
class TypeResolver(NodeVisitor):
def resolve_type(self, node: ast.Node):
self.visit(node, None)
def visit(self, node, *args):
assert len(args) == 1
if hasattr(node, "type"):
if isinstance(node.type, list):
node.type = args[0] or node.type[0]
return super().visit(node, *args)
@staticmethod
def first_intersect(left, right):
if not isinstance(left, list):
left = [left]
if not isinstance(right, list):
right = [right]
for t in left:
if t in right:
return t
def visit_Assign(self, node: ast.Assign, _: Optional[VyperType]):
self.visit(node.target, self.first_intersect(node.target.type, node.value.type))
return self.visit(node.value, node.target.type)
def visit_AugAssign(self, node: ast.AugAssign, _: Optional[VyperType]):
self.visit(node.target, self.first_intersect(node.target.type, node.value.type))
return self.visit(node.value, node.target.type)
def visit_Comparison(self, node: ast.Comparison, _: Optional[VyperType]):
self.visit(node.left, self.first_intersect(node.left.type, node.right.type))
return self.visit(node.right, node.left.type)
def visit_Equality(self, node: ast.Equality, _: Optional[VyperType]):
self.visit(node.left, self.first_intersect(node.left.type, node.right.type))
return self.visit(node.right, node.left.type)
def visit_FunctionCall(self, node: ast.FunctionCall, _: Optional[VyperType]):
self.generic_visit(node, None)
def visit_ReceiverCall(self, node: ast.ReceiverCall, _: Optional[VyperType]):
return self.generic_visit(node, None)
def visit_Set(self, node: ast.Set, _: Optional[VyperType]):
return self.generic_visit(node, None)
def visit_List(self, node: ast.List, _: Optional[VyperType]):
return self.generic_visit(node, node.type.element_type) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/analysis/type_annotator.py | type_annotator.py |
from contextlib import contextmanager
from enum import Enum
from itertools import chain
from typing import Optional, Union
from twovyper.utils import switch, first
from twovyper.ast import ast_nodes as ast, names
from twovyper.ast.nodes import VyperProgram, VyperFunction, VyperInterface
from twovyper.ast.visitors import NodeVisitor
from twovyper.exceptions import InvalidProgramException, UnsupportedException
def _assert(cond: bool, node: ast.Node, error_code: str, msg: Optional[str] = None):
if not cond:
raise InvalidProgramException(node, error_code, msg)
def check_structure(program: VyperProgram):
StructureChecker().check(program)
class _Context(Enum):
CODE = 'code'
INVARIANT = 'invariant'
LOOP_INVARIANT = 'loop.invariant'
CHECK = 'check'
POSTCONDITION = 'postcondition'
PRECONDITION = 'precondition'
TRANSITIVE_POSTCONDITION = 'transitive.postcondition'
CALLER_PRIVATE = 'caller.private'
GHOST_CODE = 'ghost.code'
GHOST_FUNCTION = 'ghost.function'
LEMMA = 'lemma'
GHOST_STATEMENT = 'ghost.statement'
@property
def is_specification(self):
return self not in [_Context.CODE, _Context.GHOST_FUNCTION, _Context.LEMMA]
@property
def is_postcondition(self):
return self in [_Context.POSTCONDITION, _Context.TRANSITIVE_POSTCONDITION]
class StructureChecker(NodeVisitor):
def __init__(self):
self.not_allowed = {
_Context.CODE: names.NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS,
_Context.INVARIANT: names.NOT_ALLOWED_IN_INVARIANT,
_Context.LOOP_INVARIANT: names.NOT_ALLOWED_IN_LOOP_INVARIANT,
_Context.CHECK: names.NOT_ALLOWED_IN_CHECK,
_Context.POSTCONDITION: names.NOT_ALLOWED_IN_POSTCONDITION,
_Context.PRECONDITION: names.NOT_ALLOWED_IN_PRECONDITION,
_Context.TRANSITIVE_POSTCONDITION: names.NOT_ALLOWED_IN_TRANSITIVE_POSTCONDITION,
_Context.CALLER_PRIVATE: names.NOT_ALLOWED_IN_CALLER_PRIVATE,
_Context.GHOST_CODE: names.NOT_ALLOWED_IN_GHOST_CODE,
_Context.GHOST_FUNCTION: names.NOT_ALLOWED_IN_GHOST_FUNCTION,
_Context.GHOST_STATEMENT: names.NOT_ALLOWED_IN_GHOST_STATEMENT,
_Context.LEMMA: names.NOT_ALLOWED_IN_LEMMAS
}
self._inside_old = False
self._is_pure = False
self._non_pure_parent_description: Union[str, None] = None
self._visited_an_event = False
self._visited_caller_spec = False
self._num_visited_conditional = 0
self._only_one_event_allowed = False
self._function_pure_checker = _FunctionPureChecker()
self._inside_performs = False
@contextmanager
def _inside_old_scope(self):
current_inside_old = self._inside_old
self._inside_old = True
yield
self._inside_old = current_inside_old
@contextmanager
def _inside_performs_scope(self):
current_inside_performs = self._inside_performs
self._inside_performs = True
yield
self._inside_performs = current_inside_performs
@contextmanager
def _inside_pure_scope(self, node_description: str = None):
is_pure = self._is_pure
self._is_pure = True
description = self._non_pure_parent_description
self._non_pure_parent_description = node_description
yield
self._is_pure = is_pure
self._non_pure_parent_description = description
@contextmanager
def _inside_one_event_scope(self):
visited_an_event = self._visited_an_event
self._visited_an_event = False
only_one_event_allowed = self._only_one_event_allowed
self._only_one_event_allowed = True
yield
self._visited_an_event = visited_an_event
self._only_one_event_allowed = only_one_event_allowed
def check(self, program: VyperProgram):
if program.resources and not program.config.has_option(names.CONFIG_ALLOCATION):
msg = "Resources require allocation config option."
raise InvalidProgramException(first(program.node.stmts) or program.node, 'alloc.not.alloc', msg)
seen_functions = set()
for implements in program.real_implements:
interface = program.interfaces.get(implements.name)
if interface is not None:
function_names = set(function.name for function in interface.functions.values())
else:
contract = program.contracts[implements.name]
function_names = set(contract.type.function_types)
_assert(not seen_functions & function_names, program.node, 'invalid.implemented.interfaces',
f'Implemented interfaces should not have a function that shares the name with another function of '
f'another implemented interface.\n'
f'(Conflicting functions: {seen_functions & function_names})')
seen_functions.update(function_names)
for function in program.functions.values():
self.visit(function.node, _Context.CODE, program, function)
if function.is_pure():
self._function_pure_checker.check_function(function, program)
for postcondition in function.postconditions:
self.visit(postcondition, _Context.POSTCONDITION, program, function)
if function.preconditions:
_assert(not function.is_public(), function.preconditions[0],
'invalid.preconditions', 'Public functions are not allowed to have preconditions.')
for precondition in function.preconditions:
self.visit(precondition, _Context.PRECONDITION, program, function)
if function.checks:
_assert(not program.is_interface(), function.checks[0],
'invalid.checks', 'No checks are allowed in interfaces.')
for check in function.checks:
self.visit(check, _Context.CHECK, program, function)
if function.performs:
_assert(function.name != names.INIT, function.performs[0],
'invalid.performs', '__init__ does not require and must not have performs clauses.')
_assert(function.is_public(), function.performs[0],
'invalid.performs', 'Private functions are not allowed to have performs clauses.')
for performs in function.performs:
self._visit_performs(performs, program, function)
for lemma in program.lemmas.values():
for default_val in lemma.defaults.values():
_assert(default_val is None, lemma.node, 'invalid.lemma')
_assert(not lemma.postconditions, first(lemma.postconditions), 'invalid.lemma',
'No postconditions are allowed for lemmas.')
_assert(not lemma.checks, first(lemma.checks), 'invalid.lemma',
'No checks are allowed for lemmas.')
_assert(not lemma.performs, first(lemma.performs), 'invalid.lemma')
self.visit(lemma.node, _Context.LEMMA, program, lemma)
for stmt in lemma.node.body:
_assert(isinstance(stmt, ast.ExprStmt), stmt, 'invalid.lemma',
'All steps of the lemma should be expressions')
for precondition in lemma.preconditions:
self.visit(precondition, _Context.LEMMA, program, lemma)
for invariant in program.invariants:
self.visit(invariant, _Context.INVARIANT, program, None)
if program.general_checks:
_assert(not program.is_interface(), program.general_checks[0],
'invalid.checks', 'No checks are allowed in interfaces.')
for check in program.general_checks:
self.visit(check, _Context.CHECK, program, None)
for postcondition in program.general_postconditions:
self.visit(postcondition, _Context.POSTCONDITION, program, None)
if program.transitive_postconditions:
_assert(not program.is_interface(), program.transitive_postconditions[0],
'invalid.transitive.postconditions', 'No transitive postconditions are allowed in interfaces')
for postcondition in program.transitive_postconditions:
self.visit(postcondition, _Context.TRANSITIVE_POSTCONDITION, program, None)
for ghost_function in program.ghost_function_implementations.values():
self.visit(ghost_function.node, _Context.GHOST_FUNCTION, program, None)
if isinstance(program, VyperInterface):
for caller_private in program.caller_private:
self._visited_caller_spec = False
self._num_visited_conditional = 0
self.visit(caller_private, _Context.CALLER_PRIVATE, program, None)
_assert(self._visited_caller_spec, caller_private, 'invalid.caller.private',
'A caller private expression must contain "caller()"')
_assert(self._num_visited_conditional <= 1, caller_private, 'invalid.caller.private',
'A caller private expression can only contain at most one "conditional(...)"')
def visit(self, node: ast.Node, *args):
assert len(args) == 3
ctx, program, function = args
_assert(ctx != _Context.GHOST_CODE or isinstance(node, ast.AllowedInGhostCode), node, 'invalid.ghost.code')
super().visit(node, ctx, program, function)
def _visit_performs(self, node: ast.Expr, program: VyperProgram, function: VyperFunction):
with self._inside_performs_scope():
_assert(isinstance(node, ast.FunctionCall) and node.name in names.GHOST_STATEMENTS,
node, 'invalid.performs')
self.visit(node, _Context.CODE, program, function)
def visit_BoolOp(self, node: ast.BoolOp, *args):
with switch(node.op) as case:
if case(ast.BoolOperator.OR):
with self._inside_one_event_scope():
with self._inside_pure_scope('disjunctions'):
self.generic_visit(node, *args)
elif case(ast.BoolOperator.IMPLIES):
with self._inside_pure_scope('(e ==> A) as the left hand side'):
self.visit(node.left, *args)
self.visit(node.right, *args)
elif case(ast.BoolOperator.AND):
self.generic_visit(node, *args)
else:
assert False
def visit_Not(self, node: ast.Not, *args):
with self._inside_pure_scope('not expressions'):
self.generic_visit(node, *args)
def visit_Containment(self, node: ast.Containment, *args):
with self._inside_pure_scope(f"containment expressions like \"{node.op}\""):
self.generic_visit(node, *args)
def visit_Equality(self, node: ast.Equality, *args):
with self._inside_pure_scope('== expressions'):
self.generic_visit(node, *args)
def visit_IfExpr(self, node: ast.IfExpr, *args):
self.visit(node.body, *args)
self.visit(node.orelse, *args)
with self._inside_pure_scope('if expressions like (A1 if e else A2)'):
self.visit(node.test, *args)
def visit_Dict(self, node: ast.Dict, *args):
with self._inside_pure_scope('dicts'):
self.generic_visit(node, *args)
def visit_List(self, node: ast.List, *args):
with self._inside_pure_scope('lists'):
self.generic_visit(node, *args)
def visit_Tuple(self, node: ast.Tuple, *args):
with self._inside_pure_scope('tuples'):
self.generic_visit(node, *args)
def visit_For(self, node: ast.For, ctx: _Context, program: VyperProgram, function: Optional[VyperFunction]):
self.generic_visit(node, ctx, program, function)
if function:
for loop_inv in function.loop_invariants.get(node, []):
self.visit(loop_inv, _Context.LOOP_INVARIANT, program, function)
def visit_FunctionDef(self, node: ast.FunctionDef, ctx: _Context,
program: VyperProgram, function: Optional[VyperFunction]):
for stmt in node.body:
if ctx == _Context.GHOST_FUNCTION or ctx == _Context.LEMMA:
new_ctx = ctx
elif ctx == _Context.CODE:
new_ctx = _Context.GHOST_CODE if stmt.is_ghost_code else ctx
else:
assert False
self.visit(stmt, new_ctx, program, function)
@staticmethod
def visit_Name(node: ast.Name, ctx: _Context, program: VyperProgram, function: Optional[VyperFunction]):
assert program
if ctx == _Context.GHOST_FUNCTION and node.id in names.ENV_VARIABLES:
_assert(False, node, 'invalid.ghost.function')
elif ctx == _Context.CALLER_PRIVATE and node.id in names.ENV_VARIABLES:
_assert(False, node, 'invalid.caller.private')
elif ctx == _Context.INVARIANT:
_assert(node.id != names.MSG, node, 'invariant.msg')
_assert(node.id != names.BLOCK, node, 'invariant.block')
elif ctx == _Context.TRANSITIVE_POSTCONDITION:
_assert(node.id != names.MSG, node, 'postcondition.msg')
elif ctx == _Context.LEMMA:
_assert(function.node.is_lemma, node, 'invalid.lemma')
_assert(node.id != names.SELF, node, 'invalid.lemma', 'Self cannot be used in lemmas')
_assert(node.id != names.MSG, node, 'invalid.lemma', 'Msg cannot be used in lemmas')
_assert(node.id != names.BLOCK, node, 'invalid.lemma', 'Block cannot be used in lemmas')
_assert(node.id != names.TX, node, 'invalid.lemma', 'Tx cannot be used in lemmas')
def visit_FunctionCall(self, node: ast.FunctionCall, ctx: _Context,
program: VyperProgram, function: Optional[VyperFunction]):
_assert(node.name not in self.not_allowed[ctx], node, f'{ctx.value}.call')
if ctx == _Context.POSTCONDITION and function and function.name == names.INIT:
_assert(node.name != names.OLD, node, 'postcondition.init.old')
if node.name == names.PUBLIC_OLD:
if ctx == _Context.POSTCONDITION:
_assert(function and function.is_private(), node, 'postcondition.public.old')
elif ctx == _Context.PRECONDITION:
_assert(function and function.is_private(), node, 'precondition.public.old')
if function and node.name == names.EVENT:
if ctx == _Context.POSTCONDITION:
_assert(function.is_private(), node, 'postcondition.event')
elif ctx == _Context.PRECONDITION:
_assert(function.is_private(), node, 'precondition.event')
if node.name in program.ghost_functions:
_assert(ctx != _Context.LEMMA, node, 'invalid.lemma')
if len(program.ghost_functions[node.name]) > 1:
if isinstance(program, VyperInterface):
cond = node.name in program.own_ghost_functions
else:
cond = node.name in program.ghost_function_implementations
_assert(cond, node, 'duplicate.ghost',
f'Multiple interfaces declare the ghost function "{node.name}".')
if node.name == names.CALLER:
self._visited_caller_spec = True
elif node.name == names.CONDITIONAL:
self._num_visited_conditional += 1
if node.name == names.LOCKED:
_assert(not isinstance(program, VyperInterface), node, 'invalid.locked',
'Locked cannot be used in an interface.')
if node.name == names.SENT or node.name == names.RECEIVED:
_assert(not program.is_interface(), node, f'invalid.{node.name}',
f'"{node.name}" cannot be used in interfaces')
elif node.name == names.EVENT:
if ctx == _Context.PRECONDITION \
or ctx == _Context.POSTCONDITION \
or ctx == _Context.LOOP_INVARIANT:
_assert(not self._is_pure, node, 'spec.event',
"Events are only in checks pure expressions. "
f"They cannot be used in {self._non_pure_parent_description}.")
if self._only_one_event_allowed:
_assert(not self._visited_an_event, node, 'spec.event',
'In this context only one event expression is allowed.')
self._visited_an_event = True
elif node.name == names.IMPLIES:
with self._inside_pure_scope('implies(e, A) as the expression "e"'):
self.visit(node.args[0], ctx, program, function)
self.visit(node.args[1], ctx, program, function)
# Success is of the form success() or success(if_not=cond1 or cond2 or ...)
elif node.name == names.SUCCESS:
def check_success_args(arg: ast.Node):
if isinstance(arg, ast.Name):
_assert(arg.id in names.SUCCESS_CONDITIONS, arg, 'spec.success')
elif isinstance(arg, ast.BoolOp) and arg.op == ast.BoolOperator.OR:
check_success_args(arg.left)
check_success_args(arg.right)
else:
raise InvalidProgramException(arg, 'spec.success')
_assert(len(node.keywords) <= 1, node, 'spec.success')
if node.keywords:
_assert(node.keywords[0].name == names.SUCCESS_IF_NOT, node, 'spec.success')
check_success_args(node.keywords[0].value)
if len(node.keywords) == 0 and len(node.args) == 1:
argument = node.args[0]
_assert(isinstance(argument, ast.ReceiverCall), node, 'spec.success')
assert isinstance(argument, ast.ReceiverCall)
func = program.functions.get(argument.name)
_assert(func is not None, argument, 'spec.success',
'Only functions defined in this contract can be called from the specification.')
_assert(func.is_pure(), argument, 'spec.success',
'Only pure functions can be called from the specification.')
self.generic_visit(argument, ctx, program, function)
elif (ctx == _Context.INVARIANT
or ctx == _Context.TRANSITIVE_POSTCONDITION
or ctx == _Context.LOOP_INVARIANT
or ctx == _Context.GHOST_CODE
or ctx == _Context.GHOST_FUNCTION):
_assert(False, node, f'{ctx.value}.call')
return
# Accessible is of the form accessible(to, amount, self.some_func(args...))
elif node.name == names.ACCESSIBLE:
_assert(not program.is_interface(), node, 'invalid.accessible', 'Accessible cannot be used in interfaces')
_assert(not self._inside_old, node, 'spec.old.accessible')
_assert(len(node.args) == 2 or len(node.args) == 3, node, 'spec.accessible')
self.visit(node.args[0], ctx, program, function)
self.visit(node.args[1], ctx, program, function)
if len(node.args) == 3:
call = node.args[2]
_assert(isinstance(call, ast.ReceiverCall), node, 'spec.accessible')
assert isinstance(call, ast.ReceiverCall)
_assert(isinstance(call.receiver, ast.Name), node, 'spec.accessible')
assert isinstance(call.receiver, ast.Name)
_assert(call.receiver.id == names.SELF, node, 'spec.accessible')
_assert(call.name in program.functions, node, 'spec.accessible')
_assert(program.functions[call.name].is_public(), node, 'spec.accessible',
"Only public functions may be used in an accessible expression")
_assert(call.name != names.INIT, node, 'spec.accessible')
self.generic_visit(call, ctx, program, function)
return
elif node.name in [names.FORALL, names.FOREACH]:
_assert(len(node.args) >= 2 and not node.keywords, node, 'invalid.no.args')
first_arg = node.args[0]
_assert(isinstance(first_arg, ast.Dict), node.args[0], f'invalid.{node.name}')
assert isinstance(first_arg, ast.Dict)
for name in first_arg.keys:
_assert(isinstance(name, ast.Name), name, f'invalid.{node.name}')
for trigger in node.args[1:len(node.args) - 1]:
_assert(isinstance(trigger, ast.Set), trigger, f'invalid.{node.name}')
self.visit(trigger, ctx, program, function)
body = node.args[-1]
if node.name == names.FOREACH:
_assert(isinstance(body, ast.FunctionCall), body, 'invalid.foreach')
assert isinstance(body, ast.FunctionCall)
_assert(body.name in names.QUANTIFIED_GHOST_STATEMENTS, body, 'invalid.foreach')
self.visit(body, ctx, program, function)
return
elif node.name in [names.OLD, names.PUBLIC_OLD]:
with self._inside_old_scope():
self.generic_visit(node, ctx, program, function)
return
elif node.name in [names.RESOURCE_PAYABLE, names.RESOURCE_PAYOUT]:
_assert(self._inside_performs, node, f'invalid.{node.name}',
f'{node.name} is only allowed in perform clauses.')
elif node.name == names.RESULT or node.name == names.REVERT:
if len(node.args) == 1:
argument = node.args[0]
_assert(isinstance(argument, ast.ReceiverCall), node, f"spec.{node.name}")
assert isinstance(argument, ast.ReceiverCall)
func = program.functions.get(argument.name)
_assert(func is not None, argument, f"spec.{node.name}",
'Only functions defined in this contract can be called from the specification.')
_assert(func.is_pure(), argument, f"spec.{node.name}",
'Only pure functions can be called from the specification.')
self.generic_visit(argument, ctx, program, function)
if node.keywords:
self.visit_nodes([kv.value for kv in node.keywords], ctx, program, function)
if node.name == names.RESULT:
_assert(func.type.return_type is not None, argument, f"spec.{node.name}",
'Only functions with a return type can be used in a result-expression.')
return
elif (ctx == _Context.CHECK
or ctx == _Context.INVARIANT
or ctx == _Context.TRANSITIVE_POSTCONDITION
or ctx == _Context.LOOP_INVARIANT
or ctx == _Context.GHOST_CODE
or ctx == _Context.GHOST_FUNCTION):
_assert(False, node, f'{ctx.value}.call')
elif node.name == names.INDEPENDENT:
with self._inside_pure_scope('independent expressions'):
self.visit(node.args[0], ctx, program, function)
def check_allowed(arg):
if isinstance(arg, ast.FunctionCall):
is_old = len(arg.args) == 1 and arg.name in [names.OLD, names.PUBLIC_OLD]
_assert(is_old, node, 'spec.independent')
return check_allowed(arg.args[0])
if isinstance(arg, ast.Attribute):
return check_allowed(arg.value)
elif isinstance(arg, ast.Name):
allowed = [names.SELF, names.BLOCK, names.CHAIN, names.TX, *function.args]
_assert(arg.id in allowed, node, 'spec.independent')
else:
_assert(False, node, 'spec.independent')
check_allowed(node.args[1])
elif node.name == names.RAW_CALL:
if names.RAW_CALL_DELEGATE_CALL in (kw.name for kw in node.keywords):
raise UnsupportedException(node, "Delegate calls are not supported.")
elif node.name == names.PREVIOUS or node.name == names.LOOP_ARRAY or node.name == names.LOOP_ITERATION:
if len(node.args) > 0:
_assert(isinstance(node.args[0], ast.Name), node.args[0], f"invalid.{node.name}")
elif node.name == names.RANGE:
if len(node.args) == 1:
_assert(isinstance(node.args[0], ast.Num), node.args[0], 'invalid.range',
'The range operator should be of the form: range(const). '
'"const" must be a constant integer expression.')
elif len(node.args) == 2:
first_arg = node.args[0]
second_arg = node.args[1]
msg = 'The range operator should be of the form: range(const1, const2) or range(x, x + const1). '\
'"const1" and "const2" must be constant integer expressions.'
if isinstance(second_arg, ast.ArithmeticOp) \
and second_arg.op == ast.ArithmeticOperator.ADD \
and ast.compare_nodes(first_arg, second_arg.left):
_assert(isinstance(second_arg.right, ast.Num), second_arg.right, 'invalid.range', msg)
else:
_assert(isinstance(first_arg, ast.Num), first_arg, 'invalid.range', msg)
_assert(isinstance(second_arg, ast.Num), second_arg, 'invalid.range', msg)
assert isinstance(first_arg, ast.Num) and isinstance(second_arg, ast.Num)
_assert(first_arg.n < second_arg.n, node, 'invalid.range',
'The range operator should be of the form: range(const1, const2). '
'"const2" must be greater than "const1".')
if node.name in names.ALLOCATION_FUNCTIONS:
msg = "Allocation statements require allocation config option."
_assert(program.config.has_option(names.CONFIG_ALLOCATION), node, 'alloc.not.alloc', msg)
if isinstance(program, VyperInterface):
_assert(not program.config.has_option(names.CONFIG_NO_PERFORMS), node, 'alloc.not.alloc')
if self._inside_performs:
_assert(node.name not in names.ALLOCATION_SPECIFICATION_FUNCTIONS, node, 'alloc.in.alloc',
'Allocation functions are not allowed in arguments of other allocation '
'functions in a performs clause')
if node.name in names.GHOST_STATEMENTS:
msg = "Allocation statements are not allowed in constant functions."
_assert(not (function and function.is_constant()), node, 'alloc.in.constant', msg)
arg_ctx = _Context.GHOST_STATEMENT if node.name in names.GHOST_STATEMENTS and not self._inside_performs else ctx
if node.name == names.TRUST and node.keywords:
_assert(not (function and function.name != names.INIT), node, 'invalid.trusted',
f'Only the "{names.INIT}" function is allowed to have trust calls with keywords.')
if node.resource:
# Resources are only allowed in allocation functions. They can have the following structure:
# - a simple name: r
# - an exchange: r <-> s
# - a creator: creator(r)
_assert(node.name in names.ALLOCATION_FUNCTIONS, node, 'invalid.no.resources')
# All allocation functions are allowed to have a resource with an address if the function is inside of a
# performs clause. Outside of performs clauses ghost statements are not allowed to have resources with
# addresses (They can only refer to their own resources).
resources_with_address_allowed = self._inside_performs or node.name not in names.GHOST_STATEMENTS
def check_resource_address(address):
_assert(resources_with_address_allowed, address, 'invalid.resource.address')
self.generic_visit(address, ctx, program, function)
if isinstance(address, ast.Name):
_assert(address.id == names.SELF, address, 'invalid.resource.address')
elif isinstance(address, ast.Attribute):
_assert(isinstance(address.value, ast.Name), address, 'invalid.resource.address')
assert isinstance(address.value, ast.Name)
_assert(address.value.id == names.SELF, address, 'invalid.resource.address')
elif isinstance(address, ast.FunctionCall):
if address.name in program.ghost_functions:
f = program.ghost_functions.get(address.name)
_assert(f is None or len(f) == 1, address, 'invalid.resource.address',
'The ghost function is not unique.')
_assert(f is not None, address, 'invalid.resource.address')
_assert(len(address.args) >= 1, address, 'invalid.resource.address')
else:
_assert(program.config.has_option(names.CONFIG_TRUST_CASTS), address,
'invalid.resource.address', 'Using casted addresses as resource address is only allowed'
'when the "trust_casts" config is set.')
_assert(address.name in program.interfaces, address, 'invalid.resource.address')
elif isinstance(address, ast.ReceiverCall):
_assert(address.name in program.ghost_functions, address, 'invalid.resource.address')
_assert(isinstance(address.receiver, ast.Name), address, 'invalid.resource.address')
assert isinstance(address.receiver, ast.Name)
f = program.interfaces[address.receiver.id].own_ghost_functions.get(address.name)
_assert(f is not None, address, 'invalid.resource.address')
_assert(len(address.args) >= 1, address, 'invalid.resource.address')
else:
_assert(False, address, 'invalid.resource.address')
def check_resource(resource: ast.Node, top: bool, inside_subscript: bool = False):
if isinstance(resource, ast.Name):
return
elif isinstance(resource, ast.Exchange) and top and not inside_subscript:
check_resource(resource.left, False, inside_subscript)
check_resource(resource.right, False, inside_subscript)
elif isinstance(resource, ast.FunctionCall) and not inside_subscript:
if resource.name == names.CREATOR:
_assert(len(resource.args) == 1 and not resource.keywords, resource, 'invalid.resource')
check_resource(resource.args[0], False, inside_subscript)
else:
if resource.resource is not None:
check_resource_address(resource.resource)
self.generic_visit(resource, arg_ctx, program, function)
elif isinstance(resource, ast.Attribute):
_assert(isinstance(resource.value, ast.Name), resource, 'invalid.resource')
assert isinstance(resource.value, ast.Name)
interface_name = resource.value.id
interface = program.interfaces.get(interface_name)
_assert(interface is not None, resource, 'invalid.resource')
_assert(resource.attr in interface.own_resources, resource, 'invalid.resource')
elif isinstance(resource, ast.ReceiverCall) and not inside_subscript:
if isinstance(resource.receiver, ast.Name):
interface_name = resource.receiver.id
elif isinstance(resource.receiver, ast.Subscript):
_assert(isinstance(resource.receiver.value, ast.Attribute), resource, 'invalid.resource')
assert isinstance(resource.receiver.value, ast.Attribute)
_assert(isinstance(resource.receiver.value.value, ast.Name), resource, 'invalid.resource')
assert isinstance(resource.receiver.value.value, ast.Name)
interface_name = resource.receiver.value.value.id
address = resource.receiver.index
check_resource_address(address)
else:
_assert(False, resource, 'invalid.resource')
return
interface = program.interfaces.get(interface_name)
_assert(interface is not None, resource, 'invalid.resource')
_assert(resource.name in interface.own_resources, resource, 'invalid.resource')
self.generic_visit(resource, arg_ctx, program, function)
elif isinstance(resource, ast.Subscript):
address = resource.index
check_resource(resource.value, False, True)
check_resource_address(address)
else:
_assert(False, resource, 'invalid.resource')
check_resource(node.resource, True)
self.visit_nodes(chain(node.args, node.keywords), arg_ctx, program, function)
def visit_ReceiverCall(self, node: ast.ReceiverCall, ctx: _Context,
program: VyperProgram, function: Optional[VyperFunction]):
if ctx == _Context.CALLER_PRIVATE:
_assert(False, node, 'spec.call')
elif ctx.is_specification or self._inside_performs:
receiver = node.receiver
if isinstance(receiver, ast.Name):
if receiver.id == names.LEMMA:
other_lemma = program.lemmas.get(node.name)
_assert(other_lemma is not None, node, 'invalid.lemma',
f'Unknown lemma to call: {node.name}')
elif receiver.id in program.interfaces:
interface = program.interfaces[receiver.id]
_assert(node.name in interface.own_ghost_functions, node, 'spec.call',
f'Unknown ghost function to call "{node.name}" in the interface "{receiver.id}"')
else:
_assert(False, node, 'spec.call')
elif ctx == _Context.GHOST_CODE:
_assert(False, node, 'invalid.ghost.code')
else:
_assert(False, node, 'spec.call')
elif ctx == _Context.GHOST_FUNCTION:
_assert(False, node, 'invalid.ghost')
elif ctx == _Context.LEMMA:
receiver = node.receiver
_assert(isinstance(receiver, ast.Name), node, 'invalid.lemma',
'Only calls to other lemmas are allowed in lemmas.')
assert isinstance(receiver, ast.Name)
_assert(receiver.id == names.LEMMA, node, 'invalid.lemma'
'Only calls to other lemmas are allowed in lemmas.')
other_lemma = program.lemmas.get(node.name)
_assert(other_lemma is not None, node, 'invalid.lemma',
f'Unknown lemma to call: {node.name}')
_assert(other_lemma.index < function.index, node, 'invalid.lemma',
'Can only use lemmas previously defined (No recursion is allowed).')
self.generic_visit(node, ctx, program, function)
def visit_Exchange(self, node: ast.Exchange, ctx: _Context,
program: VyperProgram, function: Optional[VyperFunction]):
_assert(False, node, 'exchange.not.resource')
self.generic_visit(node, ctx, program, function)
@staticmethod
def _visit_assertion(node: Union[ast.Assert, ast.Raise], ctx: _Context):
if ctx == _Context.GHOST_CODE:
if isinstance(node, ast.Assert) and node.is_lemma:
return
_assert(node.msg and isinstance(node.msg, ast.Name), node, 'invalid.ghost.code')
assert isinstance(node.msg, ast.Name)
_assert(node.msg.id == names.UNREACHABLE, node, 'invalid.ghost.code')
def visit_Assert(self, node: ast.Assert, ctx: _Context, program: VyperProgram, function: Optional[VyperFunction]):
self._visit_assertion(node, ctx)
self.generic_visit(node, ctx, program, function)
def visit_Raise(self, node: ast.Raise, ctx: _Context, program: VyperProgram, function: Optional[VyperFunction]):
self._visit_assertion(node, ctx)
self.generic_visit(node, ctx, program, function)
class _FunctionPureChecker(NodeVisitor):
"""
Checks if a given VyperFunction is pure
"""
def __init__(self):
super().__init__()
self._ghost_allowed = False
self.max_allowed_function_index = -1
@contextmanager
def _ghost_code_allowed(self):
ghost_allowed = self._ghost_allowed
self._ghost_allowed = True
yield
self._ghost_allowed = ghost_allowed
def check_function(self, function: VyperFunction, program: VyperProgram):
# A function must be constant, private and non-payable to be valid
ghost_pure_cond = not (function.is_constant() and function.is_private() and (not function.is_payable()))
pure_decorators = [decorator for decorator in function.decorators if decorator.name == names.PURE]
if len(pure_decorators) > 1:
_assert(False, pure_decorators[0], 'invalid.pure',
'A pure function can only have exactly one pure decorator')
elif pure_decorators[0].is_ghost_code and ghost_pure_cond:
_assert(False, function.node, 'invalid.pure', 'A pure function must be constant, private and non-payable')
else:
self.max_allowed_function_index = function.index - 1
# Check checks
if function.checks:
_assert(False, function.checks[0], 'invalid.pure',
'A pure function must not have checks')
# Check performs
if function.performs:
_assert(False, function.performs[0], 'invalid.pure',
'A pure function must not have performs')
# Check preconditions
if function.preconditions:
_assert(False, function.preconditions[0], 'invalid.pure',
'A pure function must not have preconditions')
# Check postconditions
if function.postconditions:
_assert(False, function.postconditions[0], 'invalid.pure',
'A pure function must not have postconditions')
# Check loop invariants
with self._ghost_code_allowed():
for loop_invariants in function.loop_invariants.values():
self.visit_nodes(loop_invariants, program)
# Check Code
self.visit_nodes(function.node.body, program)
def visit(self, node, *args):
_assert(self._ghost_allowed or not node.is_ghost_code, node, 'invalid.pure',
'A pure function must not have ghost code statements')
return super().visit(node, *args)
def visit_Name(self, node: ast.Name, program: VyperProgram):
with switch(node.id) as case:
if case(names.MSG) \
or case(names.BLOCK) \
or case(names.TX):
_assert(False, node, 'invalid.pure', 'Pure functions are not allowed to use "msg", "block" or "tx".')
self.generic_visit(node, program)
def visit_ExprStmt(self, node: ast.ExprStmt, program: VyperProgram):
if isinstance(node.value, ast.FunctionCall) and node.value.name == names.CLEAR:
# A call to clear is an assignment
self.generic_visit(node, program)
elif isinstance(node.value, ast.Str):
# long string comment
pass
else:
# all other expressions are not valid.
_assert(False, node, 'invalid.pure', 'Pure functions are not allowed to have just an expression as a '
'statement, since expressions must not have side effects.')
def visit_FunctionCall(self, node: ast.FunctionCall, program: VyperProgram):
with switch(node.name) as case:
if (
# Vyper functions with side effects
case(names.RAW_LOG)
# Specification functions with side effects
or case(names.ACCESSIBLE)
or case(names.EVENT)
or case(names.INDEPENDENT)
or case(names.REORDER_INDEPENDENT)
):
_assert(False, node, 'invalid.pure',
f'Only functions without side effects may be used in pure functions ("{node.name}" is invalid)')
elif (
# Not supported specification functions
case(names.ALLOCATED)
or case(names.FAILED)
or case(names.IMPLEMENTS)
or case(names.ISSUED)
or case(names.LOCKED)
or case(names.OFFERED)
or case(names.OUT_OF_GAS)
or case(names.OVERFLOW)
or case(names.PUBLIC_OLD)
or case(names.RECEIVED)
or case(names.SENT)
or case(names.STORAGE)
or case(names.TRUSTED)
):
_assert(False, node, 'invalid.pure',
f'This function may not be used in pure functions ("{node.name}" is invalid)')
elif case(names.SUCCESS):
_assert(len(node.keywords) == 0, node, 'invalid.pure',
f'Only success without keywords may be used in pure functions')
self.generic_visit(node, program)
def visit_ReceiverCall(self, node: ast.ReceiverCall, program: VyperProgram):
if not isinstance(node.receiver, ast.Name):
_assert(False, node, 'invalid.receiver')
with switch(node.receiver.id) as case:
if case(names.SELF):
self.generic_visit(node, program)
_assert(program.functions[node.name].is_pure(), node, 'invalid.pure',
'Pure function may only call other pure functions')
_assert(program.functions[node.name].index <= self.max_allowed_function_index, node, 'invalid.pure',
'Only functions defined above this function can be called from here')
elif case(names.LOG):
_assert(False, node, 'invalid.pure',
'Pure function may not log events.')
else:
_assert(False, node, 'invalid.pure',
'Pure function must not call functions of another contract.')
def visit_Log(self, node: ast.Log, program: VyperProgram):
raise UnsupportedException(node, 'Pure functions that log events are not supported.') | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/analysis/structure_checker.py | structure_checker.py |
from contextlib import contextmanager
from typing import Set, Dict, List
from twovyper.ast import ast_nodes as ast, names
from twovyper.ast.nodes import VyperProgram, VyperInterface, VyperFunction
from twovyper.ast.visitors import NodeVisitor
from twovyper.analysis import heuristics
from twovyper.analysis.structure_checker import check_structure
from twovyper.analysis.symbol_checker import check_symbols
from twovyper.analysis.type_annotator import TypeAnnotator
from twovyper.exceptions import UnsupportedException
from twovyper.utils import switch
def analyze(program: VyperProgram):
"""
Checks the program for structural errors, adds type information to all program expressions
and creates an analysis for each function.
"""
if isinstance(program, VyperInterface) and program.is_stub:
return
check_symbols(program)
check_structure(program)
TypeAnnotator(program).annotate_program()
function_analyzer = _FunctionAnalyzer()
program_analyzer = _ProgramAnalyzer()
invariant_analyzer = _InvariantAnalyzer()
program.analysis = ProgramAnalysis()
for function in program.functions.values():
function.analysis = FunctionAnalysis()
function_analyzer.analyze(program, function)
# The heuristics are need for analysis, therefore do them first
heuristics.compute(program)
program_analyzer.analyze(program)
invariant_analyzer.analyze(program)
class ProgramAnalysis:
def __init__(self):
# True if and only if issued state is accessed in top-level specifications
self.uses_issued = False
# The function that is used to prove accessibility if none is given
# Is set in the heuristics computation
# May be 'None' if the heuristics is not able to determine a suitable function
self.accessible_function = None
# The invariant a tag belongs to
# Each invariant has a tag that is used in accessible so we know which invariant fails
# if we cannot prove the accessibility
self.inv_tags = {}
# Maps accessible ast.ReceiverCall nodes to their tag
self.accessible_tags = {}
# All invariants that contain allocated
self.allocated_invariants = []
class FunctionAnalysis:
def __init__(self):
# True if and only if issued state is accessed in top-level or function specifications
self.uses_issued = False
# The set of tags for which accessibility needs to be proven in the function
self.accessible_tags = set()
# The set of variable names which get changed by a loop
self.loop_used_names: Dict[str, List[str]] = {}
# True if and only if "assert e, UNREACHABLE" or "raise UNREACHABLE" is used
self.uses_unreachable = False
class _ProgramAnalyzer(NodeVisitor):
def __init__(self):
super().__init__()
def analyze(self, program: VyperProgram):
self.visit_nodes(program.invariants, program)
self.visit_nodes(program.general_postconditions, program)
self.visit_nodes(program.transitive_postconditions, program)
self.visit_nodes(program.general_checks, program)
def visit_FunctionCall(self, node: ast.FunctionCall, program: VyperProgram):
if node.name == names.ISSUED:
program.analysis.uses_issued = True
for function in program.functions.values():
function.analysis.uses_issued = True
self.generic_visit(node, program)
class _InvariantAnalyzer(NodeVisitor):
def analyze(self, program: VyperProgram):
for tag, inv in enumerate(program.invariants):
program.analysis.inv_tags[tag] = inv
self.visit(inv, program, inv, tag)
def visit_FunctionCall(self, node: ast.FunctionCall, program: VyperProgram, inv: ast.Expr, tag: int):
if node.name == names.ALLOCATED:
program.analysis.allocated_invariants.append(inv)
return
elif node.name == names.ACCESSIBLE:
program.analysis.accessible_tags[node] = tag
if len(node.args) == 3:
func_arg = node.args[2]
assert isinstance(func_arg, ast.ReceiverCall)
function_name = func_arg.name
else:
if not program.analysis.accessible_function:
msg = "No matching function for accessible could be determined."
raise UnsupportedException(node, msg)
function_name = program.analysis.accessible_function.name
program.functions[function_name].analysis.accessible_tags.add(tag)
self.generic_visit(node, program, inv, tag)
class _FunctionAnalyzer(NodeVisitor):
def __init__(self):
super().__init__()
self.inside_loop = False
self.inside_spec = False
self.used_names: Set[str] = set()
@contextmanager
def _loop_scope(self):
used_variables = self.used_names
inside_loop = self.inside_loop
self.used_names = set()
self.inside_loop = True
yield
if inside_loop:
for name in used_variables:
self.used_names.add(name)
else:
self.used_names = used_variables
self.inside_loop = inside_loop
@contextmanager
def _spec_scope(self):
inside_spec = self.inside_spec
self.inside_spec = True
yield
self.inside_spec = inside_spec
def analyze(self, program: VyperProgram, function: VyperFunction):
with self._spec_scope():
self.visit_nodes(function.postconditions, program, function)
self.visit_nodes(function.preconditions, program, function)
self.visit_nodes(function.checks, program, function)
self.generic_visit(function.node, program, function)
def visit_Assert(self, node: ast.Assert, program: VyperProgram, function: VyperFunction):
if isinstance(node.msg, ast.Name) and node.msg.id == names.UNREACHABLE:
function.analysis.uses_unreachable = True
self.generic_visit(node, program, function)
def visit_FunctionCall(self, node: ast.FunctionCall, program: VyperProgram, function: VyperFunction):
if node.name == names.ISSUED:
function.analysis.uses_issued = True
self.generic_visit(node, program, function)
def visit_For(self, node: ast.For, program: VyperProgram, function: VyperFunction):
with self._loop_scope():
self.generic_visit(node, program, function)
function.analysis.loop_used_names[node.target.id] = list(self.used_names)
with self._spec_scope():
self.visit_nodes(function.loop_invariants.get(node, []), program, function)
def visit_Name(self, node: ast.Name, program: VyperProgram, function: VyperFunction):
if self.inside_loop:
with switch(node.id) as case:
if case(names.MSG)\
or case(names.BLOCK)\
or case(names.CHAIN)\
or case(names.TX):
pass
else:
self.used_names.add(node.id)
self.generic_visit(node, program, function)
def visit_Raise(self, node: ast.Raise, program: VyperProgram, function: VyperFunction):
if isinstance(node.msg, ast.Name) and node.msg.id == names.UNREACHABLE:
function.analysis.uses_unreachable = True
self.generic_visit(node, program, function) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/analysis/analyzer.py | analyzer.py |
from twovyper.utils import Subscriptable
def sign(a: int) -> int:
if a > 0:
return 1
elif a < 0:
return -1
else:
return 0
def div(a: int, b: int) -> int:
"""
Truncating division of two integers.
"""
return sign(a) * sign(b) * (abs(a) // abs(b))
def mod(a: int, b: int) -> int:
"""
Truncating modulo of two integers.
"""
return sign(a) * (abs(a) % abs(b))
class Decimal(object, metaclass=Subscriptable):
def __init__(self):
assert False
_cache = {}
def _subscript(number_of_digits: int):
# This is the function that gets called when using dictionary lookup syntax.
# For example, Decimal[10] returns a class of decimals with 10 digits. The class
# is cached so that Decimal[10] always returns the same class, which means that
# type(Decimal[10](1)) == type(Decimal[10](2)).
cached_class = Decimal._cache.get(number_of_digits)
if cached_class:
return cached_class
class _Decimal(Decimal):
def __init__(self, value: int = None, scaled_value: int = None):
assert (value is None) != (scaled_value is None)
self.number_of_digits = number_of_digits
self.scaling_factor = 10 ** number_of_digits
self.scaled_value = scaled_value if value is None else value * self.scaling_factor
def __eq__(self, other):
if isinstance(other, _Decimal):
return self.scaled_value == other.scaled_value
else:
return False
def __hash__(self):
return hash(self.scaled_value)
def __str__(self):
dv = div(self.scaled_value, self.scaling_factor)
md = mod(self.scaled_value, self.scaling_factor)
return f'{dv}.{str(md).zfill(self.number_of_digits)}'
Decimal._cache[number_of_digits] = _Decimal
return _Decimal | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/arithmetic.py | arithmetic.py |
import os
from typing import Optional, List, Dict
from twovyper.ast import ast_nodes as ast, names
from twovyper.ast.visitors import NodeVisitor
from twovyper.exceptions import InvalidProgramException
class VyperType:
def __init__(self, id: str):
self.id = id
def __str__(self) -> str:
return self.id
def __eq__(self, other) -> bool:
if isinstance(other, VyperType):
return self.id == other.id
return NotImplemented
def __hash__(self) -> int:
return hash(self.id)
class FunctionType(VyperType):
def __init__(self, arg_types: List[VyperType], return_type: Optional[VyperType]):
self.arg_types = arg_types
self.return_type = return_type
arg_type_names = [str(arg) for arg in arg_types]
id = f'({", ".join(arg_type_names)}) -> {return_type}'
super().__init__(id)
class MapType(VyperType):
def __init__(self, key_type: VyperType, value_type: VyperType):
self.key_type = key_type
self.value_type = value_type
id = f'{names.MAP}({key_type}, {value_type})'
super().__init__(id)
class ArrayType(VyperType):
def __init__(self, element_type: VyperType, size: int, is_strict: bool = True):
self.element_type = element_type
self.size = size
self.is_strict = is_strict
id = f'{element_type}[{"" if is_strict else "<="}{size}]'
super().__init__(id)
class TupleType(VyperType):
def __init__(self, element_types: List[VyperType]):
self.element_types = element_types
id = f'({element_types})'
super().__init__(id)
class StructType(VyperType):
def __init__(self, name: str, member_types: Dict[str, VyperType]):
id = f'{self.kind} {name}'
super().__init__(id)
self.name = name
self.member_types = member_types
self.member_indices = {k: i for i, k in enumerate(member_types)}
@property
def kind(self) -> str:
return 'struct'
def add_member(self, name: str, type: VyperType):
self.member_types[name] = type
self.member_indices[name] = len(self.member_indices)
class AnyStructType(VyperType):
def __init__(self):
super().__init__('$AnyStruct')
class AnyAddressType(StructType):
def __init__(self, name: str, member_types: Dict[str, VyperType]):
assert names.ADDRESS_BALANCE not in member_types
assert names.ADDRESS_CODESIZE not in member_types
assert names.ADDRESS_IS_CONTRACT not in member_types
member_types[names.ADDRESS_BALANCE] = VYPER_WEI_VALUE
member_types[names.ADDRESS_CODESIZE] = VYPER_INT128
member_types[names.ADDRESS_IS_CONTRACT] = VYPER_BOOL
super().__init__(name, member_types)
class AddressType(AnyAddressType):
def __init__(self):
super().__init__(names.ADDRESS, {})
class SelfType(AnyAddressType):
def __init__(self, member_types: Dict[str, VyperType]):
super().__init__(names.SELF, member_types)
class ResourceType(StructType):
@property
def kind(self) -> str:
return 'resource'
class UnknownResourceType(ResourceType):
def __init__(self):
super().__init__('$unknown', {})
class DerivedResourceType(ResourceType):
def __init__(self, name: str, member_types: Dict[str, VyperType], underlying_resource: ResourceType):
super().__init__(name, member_types)
self.underlying_resource = underlying_resource
class ContractType(VyperType):
def __init__(self,
name: str,
function_types: Dict[str, FunctionType],
function_modifiers: Dict[str, str]):
id = f'contract {name}'
super().__init__(id)
self.name = name
self.function_types = function_types
self.function_modifiers = function_modifiers
class InterfaceType(VyperType):
def __init__(self, name: str):
id = f'interface {name}'
super().__init__(id)
self.name = name
class StringType(ArrayType):
def __init__(self, size: int):
super().__init__(VYPER_BYTE, size, False)
self.id = f'{names.STRING}[{size}]'
class PrimitiveType(VyperType):
def __init__(self, name: str):
super().__init__(name)
self.name = name
class BoundedType(PrimitiveType):
def __init__(self, name: str, lower: int, upper: int):
super().__init__(name)
self.lower = lower
self.upper = upper
class DecimalType(BoundedType):
def __init__(self, name: str, digits: int, lower: int, upper: int):
self.number_of_digits = digits
self.scaling_factor = 10 ** digits
lower *= self.scaling_factor
upper *= self.scaling_factor
super().__init__(name, lower, upper)
class EventType(VyperType):
def __init__(self, arg_types: List[VyperType]):
arg_type_names = [str(arg) for arg in arg_types]
id = f'event({", ".join(arg_type_names)})'
super().__init__(id)
self.arg_types = arg_types
VYPER_BOOL = PrimitiveType(names.BOOL)
VYPER_INT128 = BoundedType(names.INT128, -2 ** 127, 2 ** 127 - 1)
VYPER_UINT256 = BoundedType(names.UINT256, 0, 2 ** 256 - 1)
VYPER_DECIMAL = DecimalType(names.DECIMAL, 10, -2 ** 127, 2 ** 127 - 1)
VYPER_WEI_VALUE = VYPER_UINT256
VYPER_ADDRESS = BoundedType(names.ADDRESS, 0, 2 ** 160 - 1)
VYPER_BYTE = PrimitiveType(names.BYTE)
VYPER_BYTES32 = ArrayType(VYPER_BYTE, 32, True)
NON_NEGATIVE_INT = PrimitiveType(names.NON_NEGATIVE_INTEGER)
TYPES = {
VYPER_BOOL.name: VYPER_BOOL,
VYPER_WEI_VALUE.name: VYPER_WEI_VALUE,
VYPER_INT128.name: VYPER_INT128,
VYPER_UINT256.name: VYPER_UINT256,
VYPER_DECIMAL.name: VYPER_DECIMAL,
names.WEI_VALUE: VYPER_WEI_VALUE,
VYPER_ADDRESS.name: VYPER_ADDRESS,
VYPER_BYTE.name: VYPER_BYTE,
names.BYTES32: VYPER_BYTES32,
names.STRING: VYPER_BYTE,
names.TIMESTAMP: VYPER_UINT256,
names.TIMEDELTA: VYPER_UINT256
}
MSG_TYPE = StructType(names.MSG, {
names.MSG_SENDER: VYPER_ADDRESS,
names.MSG_VALUE: VYPER_WEI_VALUE,
names.MSG_GAS: VYPER_UINT256
})
BLOCK_TYPE = StructType(names.BLOCK, {
names.BLOCK_COINBASE: VYPER_ADDRESS,
names.BLOCK_DIFFICULTY: VYPER_UINT256,
names.BLOCK_NUMBER: VYPER_UINT256,
names.BLOCK_PREVHASH: VYPER_BYTES32,
names.BLOCK_TIMESTAMP: VYPER_UINT256
})
CHAIN_TYPE = StructType(names.CHAIN, {
names.CHAIN_ID: VYPER_UINT256
})
TX_TYPE = StructType(names.TX, {
names.TX_ORIGIN: VYPER_ADDRESS
})
def is_numeric(type: VyperType) -> bool:
return type in [VYPER_INT128, VYPER_UINT256, VYPER_DECIMAL, NON_NEGATIVE_INT]
def is_bounded(type: VyperType) -> bool:
return type in [VYPER_INT128, VYPER_UINT256, VYPER_DECIMAL, VYPER_ADDRESS]
def is_integer(type: VyperType) -> bool:
return type in [VYPER_INT128, VYPER_UINT256, NON_NEGATIVE_INT]
def is_unsigned(type: VyperType) -> bool:
return type in [VYPER_UINT256, VYPER_ADDRESS, NON_NEGATIVE_INT]
def has_strict_array_size(element_type: VyperType) -> bool:
return element_type != VYPER_BYTE
def is_bytes_array(type: VyperType):
return isinstance(type, ArrayType) and type.element_type == VYPER_BYTE
def matches(t: VyperType, m: VyperType):
"""
Determines whether a type t matches a required type m in the
specifications.
Usually the types have to be the same, except non-strict arrays
which may be shorter than the expected length, and contract types
which can be used as addresses. Also, all integer types are treated
as mathematical integers.
"""
if isinstance(t, MapType) and isinstance(m, MapType) and t.key_type == m.key_type:
return matches(t.value_type, m.value_type)
elif (isinstance(t, ArrayType) and (isinstance(m, ArrayType) and not m.is_strict)
and t.element_type == m.element_type):
return t.size <= m.size
elif is_integer(t) and is_integer(m):
return True
elif isinstance(t, ContractType) and m == VYPER_ADDRESS:
return True
elif isinstance(t, InterfaceType) and m == VYPER_ADDRESS:
return True
else:
return t == m
class TypeBuilder(NodeVisitor):
def __init__(self, type_map: Dict[str, VyperType], is_stub: bool = False):
self.type_map = type_map
self.is_stub = is_stub
def build(self, node) -> VyperType:
if self.is_stub:
return VyperType('$unknown')
return self.visit(node)
@property
def method_name(self):
return '_visit'
def generic_visit(self, node):
raise InvalidProgramException(node, 'invalid.type')
def _visit_Name(self, node: ast.Name) -> VyperType:
type = self.type_map.get(node.id) or TYPES.get(node.id)
if type is None:
raise InvalidProgramException(node, 'invalid.type')
return type
def _visit_StructDef(self, node: ast.StructDef) -> VyperType:
members = {n.target.id: self.visit(n.annotation) for n in node.body}
return StructType(node.name, members)
def _visit_EventDef(self, node: ast.EventDef) -> VyperType:
arg_types = [self.visit(n.annotation) for n in node.body]
return EventType(arg_types)
def _visit_FunctionStub(self, node: ast.FunctionStub) -> VyperType:
from twovyper.ast.nodes import Resource
name, is_derived = Resource.get_name_and_derived_flag(node)
members = {n.name: self.visit(n.annotation) for n in node.args}
contract_name = os.path.split(os.path.abspath(node.file))[1].split('.')[0]
resource_name = f'{contract_name}${name}'
if is_derived:
return DerivedResourceType(resource_name, members, UnknownResourceType())
return ResourceType(resource_name, members)
def _visit_ContractDef(self, node: ast.ContractDef) -> VyperType:
functions = {}
modifiers = {}
for f in node.body:
name = f.name
arg_types = [self.visit(arg.annotation) for arg in f.args]
return_type = None if f.returns is None else self.visit(f.returns)
functions[name] = FunctionType(arg_types, return_type)
modifiers[name] = f.body[0].value.id
return ContractType(node.name, functions, modifiers)
def _visit_FunctionCall(self, node: ast.FunctionCall) -> VyperType:
# We allow
# - public, indexed: not important for verification
# - map: map type
# - event: event type
# Not allowed is
# - constant: should already be replaced
# Anything else is treated as a unit
if node.name == names.PUBLICFIELD or node.name == names.INDEXED:
return self.visit(node.args[0])
elif node.name == names.MAP:
key_type = self.visit(node.args[0])
value_type = self.visit(node.args[1])
return MapType(key_type, value_type)
elif node.name == names.EVENT:
dict_literal = node.args[0]
arg_types = [self.visit(arg) for arg in dict_literal.values]
return EventType(arg_types)
else:
type = self.type_map.get(node.name) or TYPES.get(node.name)
if type is None:
raise InvalidProgramException(node, 'invalid.type')
return type
def _visit_Subscript(self, node: ast.Subscript) -> VyperType:
element_type = self.visit(node.value)
# Array size has to be an int or a constant
# (which has already been replaced by an int)
size = node.index.n
return ArrayType(element_type, size, has_strict_array_size(element_type))
def _visit_Tuple(self, node: ast.Tuple) -> VyperType:
element_types = [self.visit(n) for n in node.elements]
return TupleType(element_types) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/types.py | types.py |
from twovyper.vyper import select_version
# Constants for names in the original AST
# Decorators
PUBLIC = select_version({'^0.2.0': 'external', '>=0.1.0-beta.16 <0.1.0': 'public'})
PRIVATE = select_version({'^0.2.0': 'internal', '>=0.1.0-beta.16 <0.1.0': 'private'})
PAYABLE = 'payable'
CONSTANT = select_version({'^0.2.0': 'view', '>=0.1.0-beta.16 <0.1.0': 'constant'})
NONREENTRANT = 'nonreentrant'
PURE = 'pure'
INTERPRETED_DECORATOR = 'interpreted'
# Modifiers
assert CONSTANT == select_version({'^0.2.0': 'view', '>=0.1.0-beta.16 <0.1.0': 'constant'})
assert PURE == 'pure'
MODIFYING = select_version({'^0.2.0': 'payable', '>=0.1.0-beta.16 <0.1.0': 'modifying'})
NONPAYABLE = select_version({'^0.2.0': 'nonpayable'}, default="")
PUBLICFIELD = 'public'
# Types
BOOL = 'bool'
INT128 = 'int128'
UINT256 = 'uint256'
DECIMAL = 'decimal'
WEI_VALUE = 'wei_value'
TIMESTAMP = 'timestamp'
TIMEDELTA = 'timedelta'
ADDRESS = 'address'
BYTE = select_version({'^0.2.0': 'Bytes', '>=0.1.0-beta.16 <0.1.0': 'bytes'})
BYTES32 = 'bytes32'
STRING = select_version({'^0.2.0': 'String', '>=0.1.0-beta.16 <0.1.0': 'string'})
MAP = select_version({'^0.2.0': 'HashMap', '>=0.1.0-beta.16 <0.1.0': 'map'})
EVENT = 'event'
NON_NEGATIVE_INTEGER = "non_negative_integer"
# Functions
INIT = '__init__'
# Variables
ADDRESS_BALANCE = 'balance'
ADDRESS_CODESIZE = 'codesize'
ADDRESS_IS_CONTRACT = 'is_contract'
SELF = 'self'
MSG = 'msg'
MSG_SENDER = 'sender'
MSG_VALUE = 'value'
MSG_GAS = 'gas'
BLOCK = 'block'
BLOCK_COINBASE = 'coinbase'
BLOCK_DIFFICULTY = 'difficulty'
BLOCK_NUMBER = 'number'
BLOCK_PREVHASH = 'prevhash'
BLOCK_TIMESTAMP = 'timestamp'
CHAIN = 'chain'
CHAIN_ID = 'id'
TX = 'tx'
TX_ORIGIN = 'origin'
LOG = 'log'
LEMMA = 'lemma'
ENV_VARIABLES = [MSG, BLOCK, CHAIN, TX]
# Constants
EMPTY_BYTES32 = 'EMPTY_BYTES32'
ZERO_ADDRESS = 'ZERO_ADDRESS'
ZERO_WEI = 'ZERO_WEI'
MIN_INT128 = 'MIN_INT128'
MAX_INT128 = 'MAX_INT128'
MAX_UINT256 = 'MAX_UINT256'
MIN_DECIMAL = 'MIN_DECIMAL'
MAX_DECIMAL = 'MAX_DECIMAL'
CONSTANT_VALUES = {
EMPTY_BYTES32: 'b"' + '\\x00' * 32 + '"',
ZERO_ADDRESS: '0',
ZERO_WEI: '0',
MIN_INT128: f'-{2 ** 127}',
MAX_INT128: f'{2 ** 127 - 1}',
MAX_UINT256: f'{2 ** 256 - 1}',
MIN_DECIMAL: f'-{2 ** 127}.0',
MAX_DECIMAL: f'{2 ** 127 - 1}.0'
}
# Special
UNITS = 'units'
IMPLEMENTS = 'implements'
INDEXED = 'indexed'
UNREACHABLE = 'UNREACHABLE'
# Ether units
ETHER_UNITS = {
'wei': 1,
('femtoether', 'kwei', 'babbage'): 10 ** 3,
('picoether', 'mwei', 'lovelace'): 10 ** 6,
('nanoether', 'gwei', 'shannon'): 10 ** 9,
('microether', 'szabo'): 10 ** 12,
('milliether', 'finney'): 10 ** 15,
'ether': 10 ** 18,
('kether', 'grand'): 10 ** 21
}
# Built-in functions
MIN = 'min'
MAX = 'max'
ADDMOD = 'uint256_addmod'
MULMOD = 'uint256_mulmod'
SQRT = 'sqrt'
FLOOR = 'floor'
CEIL = 'ceil'
SHIFT = 'shift'
BITWISE_NOT = 'bitwise_not'
BITWISE_AND = 'bitwise_and'
BITWISE_OR = 'bitwise_or'
BITWISE_XOR = 'bitwise_xor'
AS_WEI_VALUE = 'as_wei_value'
AS_UNITLESS_NUMBER = 'as_unitless_number'
CONVERT = 'convert'
EXTRACT32 = 'extract32'
EXTRACT32_TYPE = select_version({'^0.2.0': 'output_type', '>=0.1.0-beta.16 <0.1.0': 'type'})
RANGE = 'range'
LEN = 'len'
CONCAT = 'concat'
KECCAK256 = 'keccak256'
SHA256 = 'sha256'
ECRECOVER = 'ecrecover'
ECADD = 'ecadd'
ECMUL = 'ecmul'
BLOCKHASH = 'blockhash'
METHOD_ID = 'method_id'
METHOD_ID_OUTPUT_TYPE = select_version({'^0.2.0': 'output_type'}, default="")
EMPTY = select_version({'^0.2.0': 'empty'}, default="")
ASSERT_MODIFIABLE = select_version({'>=0.1.0-beta.16 <0.1.0': 'assert_modifiable'}, default="")
CLEAR = 'clear'
SELFDESTRUCT = 'selfdestruct'
SEND = 'send'
RAW_CALL = 'raw_call'
RAW_CALL_OUTSIZE = select_version({'^0.2.0': 'max_outsize', '>=0.1.0-beta.16 <0.1.0': 'outsize'})
RAW_CALL_VALUE = 'value'
RAW_CALL_GAS = 'gas'
RAW_CALL_DELEGATE_CALL = 'delegate_call'
RAW_CALL_IS_STATIC_CALL = select_version({'^0.2.0': 'is_static_call'}, default="")
RAW_LOG = 'raw_log'
CREATE_FORWARDER_TO = 'create_forwarder_to'
CREATE_FORWARDER_TO_VALUE = 'value'
# Verification
INVARIANT = 'invariant'
INTER_CONTRACT_INVARIANTS = 'inter_contract_invariant'
GENERAL_POSTCONDITION = 'always_ensures'
GENERAL_CHECK = 'always_check'
POSTCONDITION = 'ensures'
PRECONDITION = 'requires'
CHECK = 'check'
CALLER_PRIVATE = 'caller_private'
PERFORMS = 'performs'
CONFIG = 'config'
CONFIG_ALLOCATION = 'allocation'
CONFIG_NO_GAS = 'no_gas'
CONFIG_NO_OVERFLOWS = 'no_overflows'
CONFIG_NO_PERFORMS = 'no_performs'
CONFIG_NO_DERIVED_WEI = 'no_derived_wei_resource'
CONFIG_TRUST_CASTS = 'trust_casts'
CONFIG_OPTIONS = [CONFIG_ALLOCATION, CONFIG_NO_GAS, CONFIG_NO_OVERFLOWS, CONFIG_NO_PERFORMS, CONFIG_NO_DERIVED_WEI,
CONFIG_TRUST_CASTS]
INTERFACE = 'internal_interface'
IMPLIES = 'implies'
FORALL = 'forall'
SUM = 'sum'
TUPLE = 'tuple'
RESULT = 'result'
RESULT_DEFAULT = 'default'
STORAGE = 'storage'
OLD = 'old'
PUBLIC_OLD = 'public_old'
ISSUED = 'issued'
SENT = 'sent'
RECEIVED = 'received'
ACCESSIBLE = 'accessible'
INDEPENDENT = 'independent'
REORDER_INDEPENDENT = 'reorder_independent'
assert EVENT == 'event' # EVENT = 'event'
assert SELFDESTRUCT == 'selfdestruct' # SELFDESTRUCT = 'selfdestruct'
assert IMPLEMENTS == 'implements' # IMPLEMENTS = 'implements'
LOCKED = 'locked'
REVERT = 'revert'
PREVIOUS = 'previous'
LOOP_ARRAY = 'loop_array'
LOOP_ITERATION = 'loop_iteration'
INTERPRETED = 'interpreted'
CONDITIONAL = 'conditional'
OVERFLOW = 'overflow'
OUT_OF_GAS = 'out_of_gas'
FAILED = 'failed'
CALLER = 'caller'
SUCCESS = 'success'
SUCCESS_IF_NOT = 'if_not'
SUCCESS_OVERFLOW = 'overflow'
SUCCESS_OUT_OF_GAS = 'out_of_gas'
SUCCESS_SENDER_FAILED = 'sender_failed'
SUCCESS_CONDITIONS = [SUCCESS_OVERFLOW, SUCCESS_OUT_OF_GAS, SUCCESS_SENDER_FAILED]
WEI = 'wei'
UNDERLYING_WEI = 'Wei'
ALLOCATED = 'allocated'
OFFERED = 'offered'
NO_OFFERS = 'no_offers'
TRUST_NO_ONE = 'trust_no_one'
TRUSTED = 'trusted'
TRUSTED_BY = 'by'
TRUSTED_WHERE = 'where'
REALLOCATE = 'reallocate'
REALLOCATE_TO = 'to'
REALLOCATE_ACTOR = 'actor'
RESOURCE_PAYOUT = 'payout'
RESOURCE_PAYOUT_ACTOR = 'actor'
RESOURCE_PAYABLE = 'payable'
RESOURCE_PAYABLE_ACTOR = 'actor'
FOREACH = 'foreach'
OFFER = 'offer'
OFFER_TO = 'to'
OFFER_ACTOR = 'actor'
OFFER_TIMES = 'times'
ALLOW_TO_DECOMPOSE = 'allow_to_decompose'
ALLOWED_TO_DECOMPOSE = 'allowed_to_decompose'
REVOKE = 'revoke'
REVOKE_TO = 'to'
REVOKE_ACTOR = 'actor'
EXCHANGE = 'exchange'
EXCHANGE_TIMES = 'times'
CREATE = 'create'
CREATE_TO = 'to'
CREATE_ACTOR = 'actor'
DESTROY = 'destroy'
DESTROY_ACTOR = 'actor'
TRUST = 'trust'
TRUST_ACTOR = 'actor'
ALLOCATE_UNTRACKED = 'allocate_untracked_wei'
CREATOR = 'creator'
RESOURCE_PREFIX = "r_"
DERIVED_RESOURCE_PREFIX = "d_"
GHOST_STATEMENTS = [REALLOCATE, FOREACH, OFFER, REVOKE, EXCHANGE, CREATE, DESTROY, TRUST, ALLOCATE_UNTRACKED,
ALLOW_TO_DECOMPOSE, RESOURCE_PAYABLE, RESOURCE_PAYOUT]
QUANTIFIED_GHOST_STATEMENTS = [OFFER, REVOKE, CREATE, DESTROY, TRUST]
SPECIAL_RESOURCES = [WEI, CREATOR]
ALLOCATION_SPECIFICATION_FUNCTIONS = [ALLOCATED, OFFERED, NO_OFFERS, TRUSTED, TRUST_NO_ONE, ALLOWED_TO_DECOMPOSE]
ALLOCATION_FUNCTIONS = [*ALLOCATION_SPECIFICATION_FUNCTIONS, *GHOST_STATEMENTS]
NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS = [PREVIOUS, LOOP_ARRAY, LOOP_ITERATION]
NOT_ALLOWED_IN_SPEC = [ASSERT_MODIFIABLE, CLEAR, SEND, RAW_CALL, RAW_LOG, CREATE_FORWARDER_TO]
NOT_ALLOWED_IN_INVARIANT = [*NOT_ALLOWED_IN_SPEC, CALLER, OVERFLOW, OUT_OF_GAS, FAILED, ISSUED, BLOCKHASH,
INDEPENDENT, REORDER_INDEPENDENT, EVENT, PUBLIC_OLD, INTERPRETED, CONDITIONAL,
*NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, *GHOST_STATEMENTS]
NOT_ALLOWED_IN_LOOP_INVARIANT = [*NOT_ALLOWED_IN_SPEC, CALLER, ACCESSIBLE, OVERFLOW, OUT_OF_GAS, FAILED,
ACCESSIBLE, INDEPENDENT, REORDER_INDEPENDENT, INTERPRETED, CONDITIONAL,
*GHOST_STATEMENTS]
NOT_ALLOWED_IN_CHECK = [*NOT_ALLOWED_IN_SPEC, CALLER, INDEPENDENT, ACCESSIBLE, PUBLIC_OLD,
INTERPRETED, CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, *GHOST_STATEMENTS]
NOT_ALLOWED_IN_POSTCONDITION = [*NOT_ALLOWED_IN_SPEC, CALLER, ACCESSIBLE, INTERPRETED, CONDITIONAL,
*NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, *GHOST_STATEMENTS]
NOT_ALLOWED_IN_PRECONDITION = [*NOT_ALLOWED_IN_SPEC, CALLER, ACCESSIBLE, SUCCESS, REVERT, OVERFLOW, OUT_OF_GAS, FAILED,
RESULT, ACCESSIBLE, OLD, INDEPENDENT, REORDER_INDEPENDENT,
INTERPRETED, CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, *GHOST_STATEMENTS]
NOT_ALLOWED_IN_TRANSITIVE_POSTCONDITION = [*NOT_ALLOWED_IN_SPEC, CALLER, OVERFLOW, OUT_OF_GAS, FAILED,
INDEPENDENT, REORDER_INDEPENDENT, EVENT, ACCESSIBLE, PUBLIC_OLD,
INTERPRETED, CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS,
*GHOST_STATEMENTS]
NOT_ALLOWED_IN_CALLER_PRIVATE = [*NOT_ALLOWED_IN_SPEC, IMPLIES, FORALL, SUM, RESULT, STORAGE, OLD, PUBLIC_OLD, ISSUED,
SENT, RECEIVED, ACCESSIBLE, INDEPENDENT, REORDER_INDEPENDENT, EVENT, SELFDESTRUCT,
IMPLEMENTS, LOCKED, REVERT, OVERFLOW, OUT_OF_GAS, FAILED, SUCCESS,
BLOCKHASH, *ALLOCATION_FUNCTIONS, INTERPRETED, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS]
NOT_ALLOWED_IN_GHOST_CODE = [*NOT_ALLOWED_IN_SPEC, CALLER, OVERFLOW, OUT_OF_GAS, FAILED, INDEPENDENT,
REORDER_INDEPENDENT, ACCESSIBLE, PUBLIC_OLD, SELFDESTRUCT,
CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS]
NOT_ALLOWED_IN_GHOST_FUNCTION = [*NOT_ALLOWED_IN_SPEC, CALLER, OVERFLOW, OUT_OF_GAS, FAILED,
STORAGE, OLD, PUBLIC_OLD, ISSUED, BLOCKHASH, SENT, RECEIVED, ACCESSIBLE,
INDEPENDENT, REORDER_INDEPENDENT, SELFDESTRUCT, INTERPRETED, CONDITIONAL,
*NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, *GHOST_STATEMENTS]
NOT_ALLOWED_IN_GHOST_STATEMENT = [*NOT_ALLOWED_IN_SPEC, CALLER, SUCCESS, REVERT, OVERFLOW, OUT_OF_GAS, FAILED, RESULT,
ACCESSIBLE, INDEPENDENT, REORDER_INDEPENDENT, PUBLIC_OLD, SELFDESTRUCT,
INTERPRETED, CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS]
NOT_ALLOWED_IN_LEMMAS = [*NOT_ALLOWED_IN_SPEC, RESULT, STORAGE, OLD, PUBLIC_OLD, ISSUED, SENT, RECEIVED, ACCESSIBLE,
INDEPENDENT, REORDER_INDEPENDENT, EVENT, SELFDESTRUCT, IMPLEMENTS, LOCKED, REVERT,
INTERPRETED, CONDITIONAL, *NOT_ALLOWED_BUT_IN_LOOP_INVARIANTS, OVERFLOW, OUT_OF_GAS, FAILED,
CALLER, SUCCESS, *ALLOCATION_FUNCTIONS]
# Heuristics
WITHDRAW = 'withdraw' | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/names.py | names.py |
from twovyper.ast import names
from twovyper.ast import types
from twovyper.ast.types import ContractType, FunctionType, ArrayType
VYPER_INTERFACES = ['vyper', 'interfaces']
ERC20 = 'ERC20'
ERC721 = 'ERC721'
ERC20_FUNCTIONS = {
'totalSupply': FunctionType([], types.VYPER_UINT256),
'balanceOf': FunctionType([types.VYPER_ADDRESS], types.VYPER_UINT256),
'allowance': FunctionType([types.VYPER_ADDRESS, types.VYPER_ADDRESS], types.VYPER_UINT256),
'transfer': FunctionType([types.VYPER_ADDRESS, types.VYPER_UINT256], types.VYPER_BOOL),
'transferFrom': FunctionType([types.VYPER_ADDRESS, types.VYPER_ADDRESS, types.VYPER_UINT256], types.VYPER_BOOL),
'approve': FunctionType([types.VYPER_ADDRESS, types.VYPER_UINT256], types.VYPER_BOOL)
}
ERC20_MODIFIERS = {
'totalSupply': names.CONSTANT,
'balanceOf': names.CONSTANT,
'allowance': names.MODIFYING,
'transfer': names.MODIFYING,
'transferFrom': names.MODIFYING,
'approve': names.MODIFYING
}
_BYTES1024 = ArrayType(types.VYPER_BYTE, 1024, False)
ERC721_FUNCTIONS = {
'supportsInterfaces': FunctionType([types.VYPER_BYTES32], types.VYPER_BOOL),
'balanceOf': FunctionType([types.VYPER_ADDRESS], types.VYPER_UINT256),
'ownerOf': FunctionType([types.VYPER_UINT256], types.VYPER_ADDRESS),
'getApproved': FunctionType([types.VYPER_UINT256], types.VYPER_ADDRESS),
'isApprovedForAll': FunctionType([types.VYPER_ADDRESS, types.VYPER_ADDRESS], types.VYPER_BOOL),
'transferFrom': FunctionType([types.VYPER_ADDRESS, types.VYPER_ADDRESS, types.VYPER_UINT256], types.VYPER_BOOL),
'safeTransferFrom': FunctionType([types.VYPER_ADDRESS, types.VYPER_ADDRESS, types.VYPER_UINT256, _BYTES1024], None),
'approve': FunctionType([types.VYPER_ADDRESS, types.VYPER_UINT256], None),
'setApprovalForAll': FunctionType([types.VYPER_ADDRESS, types.VYPER_BOOL], None)
}
ERC721_MODIFIERS = {
'supportsInterfaces': names.CONSTANT,
'balanceOf': names.CONSTANT,
'ownerOf': names.CONSTANT,
'getApproved': names.CONSTANT,
'isApprovedForAll': names.CONSTANT,
'transferFrom': names.MODIFYING,
'safeTransferFrom': names.MODIFYING,
'approve': names.MODIFYING,
'setApprovalForAll': names.MODIFYING
}
ERC20_TYPE = ContractType(ERC20, ERC20_FUNCTIONS, ERC20_MODIFIERS)
ERC721_TYPE = ContractType(ERC721, ERC721_FUNCTIONS, ERC721_MODIFIERS) | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/interfaces.py | interfaces.py |
import os
from collections import defaultdict
from itertools import chain
from typing import Dict, Iterable, List, Optional, Set, Tuple, TYPE_CHECKING
from twovyper.ast import ast_nodes as ast, names
from twovyper.ast.types import (
VyperType, FunctionType, StructType, ResourceType, ContractType, EventType, InterfaceType, DerivedResourceType
)
if TYPE_CHECKING:
from twovyper.analysis.analyzer import FunctionAnalysis, ProgramAnalysis
class Config:
def __init__(self, options: List[str]):
self.options = options
def has_option(self, option: str) -> bool:
return option in self.options
class VyperVar:
def __init__(self, name: str, type: VyperType, node):
self.name = name
self.type = type
self.node = node
class VyperFunction:
def __init__(self,
name: str,
index: int,
args: Dict[str, VyperVar],
defaults: Dict[str, Optional[ast.Expr]],
type: FunctionType,
postconditions: List[ast.Expr],
preconditions: List[ast.Expr],
checks: List[ast.Expr],
loop_invariants: Dict[ast.For, List[ast.Expr]],
performs: List[ast.FunctionCall],
decorators: List[ast.Decorator],
node: Optional[ast.FunctionDef]):
self.name = name
self.index = index
self.args = args
self.defaults = defaults
self.type = type
self.postconditions = postconditions
self.preconditions = preconditions
self.checks = checks
self.loop_invariants = loop_invariants
self.performs = performs
self.decorators = decorators
self.node = node
# Gets set in the analyzer
self.analysis: Optional[FunctionAnalysis] = None
@property
def _decorator_names(self) -> Iterable[str]:
for dec in self.decorators:
yield dec.name
def is_public(self) -> bool:
return names.PUBLIC in self._decorator_names
def is_private(self) -> bool:
return names.PRIVATE in self._decorator_names
def is_payable(self) -> bool:
return names.PAYABLE in self._decorator_names
def is_constant(self) -> bool:
return names.CONSTANT in self._decorator_names
def is_pure(self) -> bool:
return names.PURE in self._decorator_names
def is_interpreted(self) -> bool:
return names.INTERPRETED_DECORATOR in self._decorator_names
def nonreentrant_keys(self) -> Iterable[str]:
for dec in self.decorators:
if dec.name == names.NONREENTRANT:
yield dec.args[0].s
class GhostFunction:
def __init__(self,
name: str,
args: Dict[str, VyperVar],
type: FunctionType,
node: ast.FunctionDef,
file: str):
self.name = name
self.args = args
self.type = type
self.node = node
self.file = file
@property
def interface(self):
return os.path.split(self.file)[1].split('.')[0] if self.file else ''
class VyperStruct:
def __init__(self,
name: str,
type: StructType,
node: Optional[ast.Node]):
self.name = name
self.type = type
self.node = node
class Resource(VyperStruct):
def __init__(self,
rtype: ResourceType,
node: Optional[ast.Node],
file: Optional[str],
underlying_resource_node: Optional[ast.Expr] = None):
super().__init__(rtype.name, rtype, node)
self.file = file
self.analysed = False
self._own_address = None
self.underlying_resource = underlying_resource_node
self.underlying_address = None
self.derived_resources = []
@property
def interface(self):
return os.path.split(self.file)[1].split('.')[0] if self.file else ''
@property
def underlying_resource_name(self):
return self.type.underlying_resource.name if isinstance(self.type, DerivedResourceType) else None
@property
def own_address(self):
if self.analysed:
raise AssertionError("The own address attribute is only available during the analysing phase.")
return self._own_address
@own_address.setter
def own_address(self, expr: ast.Expr):
self._own_address = expr
def is_derived_resource(self):
return self.underlying_resource_name is not None
@staticmethod
def get_name_and_derived_flag(node) -> Tuple[str, bool]:
if node.name.startswith(names.DERIVED_RESOURCE_PREFIX):
return node.name[len(names.DERIVED_RESOURCE_PREFIX):], True
assert node.name.startswith(names.RESOURCE_PREFIX)
return node.name[len(names.RESOURCE_PREFIX):], False
class VyperContract:
def __init__(self, name: str, type: ContractType, node: Optional[ast.ContractDef]):
self.name = name
self.type = type
self.node = node
class VyperEvent:
def __init__(self, name: str, type: EventType):
self.name = name
self.type = type
class VyperProgram:
def __init__(self,
node: ast.Module,
file: str,
config: Config,
fields: VyperStruct,
functions: Dict[str, VyperFunction],
interfaces: Dict[str, 'VyperInterface'],
structs: Dict[str, VyperStruct],
contracts: Dict[str, VyperContract],
events: Dict[str, VyperEvent],
resources: Dict[str, Resource],
local_state_invariants: List[ast.Expr],
inter_contract_invariants: List[ast.Expr],
general_postconditions: List[ast.Expr],
transitive_postconditions: List[ast.Expr],
general_checks: List[ast.Expr],
lemmas: Dict[str, VyperFunction],
implements: List[InterfaceType],
real_implements: List[InterfaceType],
ghost_function_implementations: Dict[str, GhostFunction]):
self.node = node
self.file = file
self.config = config
self.fields = fields
self.functions = functions
self.interfaces = interfaces
self.structs = structs
self.contracts = contracts
self.events = events
self.imported_resources: Dict[str, List[Resource]] = defaultdict(list)
for key, value in self._resources():
self.imported_resources[key].append(value)
self.own_resources = resources
self.declared_resources = dict((name, resource) for name, resource in self.own_resources.items()
if name != names.WEI and name != names.UNDERLYING_WEI)
self.resources: Dict[str, List[Resource]] = defaultdict(list, self.imported_resources)
for key, value in resources.items():
self.resources[key].append(value)
self.local_state_invariants = local_state_invariants
self.inter_contract_invariants = inter_contract_invariants
self.general_postconditions = general_postconditions
self.transitive_postconditions = transitive_postconditions
self.general_checks = general_checks
self.lemmas = lemmas
self.implements = implements
self.real_implements = real_implements
self.ghost_functions: Dict[str, List[GhostFunction]] = defaultdict(list)
for key, value in self._ghost_functions():
self.ghost_functions[key].append(value)
self.ghost_function_implementations = ghost_function_implementations
self.type = fields.type
# Is set in the analyzer
self.analysis: Optional[ProgramAnalysis] = None
def is_interface(self) -> bool:
return False
def nonreentrant_keys(self) -> Set[str]:
s = set()
for func in self.functions.values():
for key in func.nonreentrant_keys():
s.add(key)
return s
def _ghost_functions(self) -> Iterable[Tuple[str, GhostFunction]]:
for interface in self.interfaces.values():
for name, func in interface.own_ghost_functions.items():
yield name, func
def _resources(self) -> Iterable[Tuple[str, Resource]]:
for interface in self.interfaces.values():
for name, resource in interface.declared_resources.items():
yield name, resource
@property
def invariants(self):
return chain(self.local_state_invariants, self.inter_contract_invariants)
class VyperInterface(VyperProgram):
def __init__(self,
node: ast.Module,
file: str,
name: Optional[str],
config: Config,
functions: Dict[str, VyperFunction],
interfaces: Dict[str, 'VyperInterface'],
resources: Dict[str, Resource],
local_state_invariants: List[ast.Expr],
inter_contract_invariants: List[ast.Expr],
general_postconditions: List[ast.Expr],
transitive_postconditions: List[ast.Expr],
general_checks: List[ast.Expr],
caller_private: List[ast.Expr],
ghost_functions: Dict[str, GhostFunction],
type: InterfaceType,
is_stub=False):
struct_name = f'{name}$self'
empty_struct_type = StructType(struct_name, {})
empty_struct = VyperStruct(struct_name, empty_struct_type, None)
super().__init__(node,
file,
config,
empty_struct,
functions,
interfaces,
{}, {}, {},
resources,
local_state_invariants,
inter_contract_invariants,
general_postconditions,
transitive_postconditions,
general_checks,
{}, [], [], {})
self.name = name
self.imported_ghost_functions: Dict[str, List[GhostFunction]] = defaultdict(list)
for key, value in self._ghost_functions():
self.imported_ghost_functions[key].append(value)
self.own_ghost_functions = ghost_functions
self.ghost_functions: Dict[str, List[GhostFunction]] = defaultdict(list, self.imported_ghost_functions)
for key, value in ghost_functions.items():
self.ghost_functions[key].append(value)
self.type = type
self.caller_private = caller_private
self.is_stub = is_stub
def is_interface(self) -> bool:
return True | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/nodes.py | nodes.py |
from typing import Iterable, List, Optional, Tuple, Union
from twovyper.ast import ast_nodes as ast
def children(node: ast.Node) -> Iterable[Tuple[str, Union[Optional[ast.Node], List[ast.Node]]]]:
for child in node.children:
yield child, getattr(node, child)
# TODO: improve
def descendants(node: ast.Node) -> Iterable[ast.Node]:
for _, child in children(node):
if child is None:
continue
elif isinstance(child, ast.Node):
yield child
for child_child in descendants(child):
yield child_child
elif isinstance(child, List):
for child_child in child:
yield child_child
for child_child_child in descendants(child_child):
yield child_child_child
class NodeVisitor:
@property
def method_name(self) -> str:
return 'visit'
def visit(self, node, *args):
method = f'{self.method_name}_{node.__class__.__name__}'
visitor = getattr(self, method, self.generic_visit)
return visitor(node, *args)
def visit_nodes(self, nodes: Iterable[ast.Node], *args):
for node in nodes:
self.visit(node, *args)
return None
def generic_visit(self, node, *args):
for _, value in children(node):
if value is None:
continue
elif isinstance(value, ast.Node):
self.visit(value, *args)
elif isinstance(value, list):
for item in value:
self.visit(item, *args)
else:
assert False
return None
class NodeTransformer(NodeVisitor):
def generic_visit(self, node, *args):
for field, old_value in children(node):
if old_value is None:
continue
elif isinstance(old_value, ast.Node):
new_node = self.visit(old_value, *args)
if new_node is None:
delattr(node, field)
else:
setattr(node, field, new_node)
elif isinstance(old_value, list):
new_values = []
for value in old_value:
new_value = self.visit(value)
if new_value is None:
continue
else:
new_values.append(new_value)
old_value[:] = new_values
else:
assert False
return node | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/visitors.py | visitors.py |
from enum import Enum
from typing import List as ListT, Optional as OptionalT
class Node:
_children: ListT[str] = []
def __init__(self):
self.file = None
self.lineno = None
self.col_offset = None
self.end_lineno = None
self.end_col_offset = None
self.is_ghost_code = False
@property
def children(self):
return self._children
class AllowedInGhostCode:
pass
class Stmt(Node):
pass
class Expr(Node, AllowedInGhostCode):
def __init__(self):
super().__init__()
self.type = None
class Operator(AllowedInGhostCode):
pass
class BoolOperator(Operator, Enum):
AND = 'and'
OR = 'or'
IMPLIES = 'implies'
class BoolOp(Expr):
_children = ['left', 'right']
def __init__(self, left: Expr, op: BoolOperator, right: Expr):
super().__init__()
self.left = left
self.op = op
self.right = right
class Not(Expr):
_children = ['operand']
def __init__(self, operand: Expr):
super().__init__()
self.operand = operand
class ArithmeticOperator(Operator, Enum):
ADD = '+'
SUB = '-'
MUL = '*'
DIV = '/'
MOD = '%'
POW = '**'
class ArithmeticOp(Expr):
_children = ['left', 'right']
def __init__(self, left: Expr, op: ArithmeticOperator, right: Expr):
super().__init__()
self.left = left
self.op = op
self.right = right
class UnaryArithmeticOperator(Operator, Enum):
ADD = '+'
SUB = '-'
class UnaryArithmeticOp(Expr):
_children = ['operand']
def __init__(self, op: UnaryArithmeticOperator, operand: Expr):
super().__init__()
self.op = op
self.operand = operand
class ComparisonOperator(Operator, Enum):
LT = '<'
LTE = '<='
GTE = '>='
GT = '>'
class Comparison(Expr):
_children = ['left', 'right']
def __init__(self, left: Expr, op: ComparisonOperator, right: Expr):
super().__init__()
self.left = left
self.op = op
self.right = right
class ContainmentOperator(Operator, Enum):
IN = 'in'
NOT_IN = 'not in'
class Containment(Expr):
_children = ['value', 'list']
def __init__(self, value: Expr, op: ContainmentOperator, list_expr: Expr):
super().__init__()
self.value = value
self.op = op
self.list = list_expr
class EqualityOperator(Operator, Enum):
EQ = '=='
NEQ = '!='
class Equality(Expr):
_children = ['left', 'right']
def __init__(self, left: Expr, op: EqualityOperator, right: Expr):
super().__init__()
self.left = left
self.op = op
self.right = right
class IfExpr(Expr):
_children = ['test', 'body', 'orelse']
def __init__(self, test: Expr, body: Expr, orelse: Expr):
super().__init__()
self.test = test
self.body = body
self.orelse = orelse
class Set(Expr):
_children = ['elements']
def __init__(self, elements: ListT[Expr]):
super().__init__()
self.elements = elements
class Keyword(Node, AllowedInGhostCode):
_children = ['value']
def __init__(self, name: str, value: Expr):
super().__init__()
self.name = name
self.value = value
class FunctionCall(Expr):
_children = ['args', 'keywords', 'resource']
def __init__(self, name: str, args: ListT[Expr], keywords: ListT[Keyword], resource: OptionalT[Expr] = None):
super().__init__()
self.name = name
self.args = args
self.keywords = keywords
self.resource = resource
self.underlying_resource = None
class ReceiverCall(Expr):
_children = ['receiver', 'args', 'keywords']
def __init__(self, name: str, receiver: Expr, args: ListT[Expr], keywords: ListT[Keyword]):
super().__init__()
self.name = name
self.receiver = receiver
self.args = args
self.keywords = keywords
class Num(Expr):
def __init__(self, n):
super().__init__()
self.n = n
class Str(Expr):
def __init__(self, s: str):
super().__init__()
self.s = s
class Bytes(Expr):
def __init__(self, s: bytes):
super().__init__()
self.s = s
class Bool(Expr):
def __init__(self, value):
super().__init__()
self.value = value
class Ellipsis(Expr):
pass
class Exchange(Expr):
_children = ['left', 'right']
def __init__(self, left: Expr, right: Expr):
super().__init__()
self.left = left
self.right = right
class Attribute(Expr):
_children = ['value']
def __init__(self, value: Expr, attr: str):
super().__init__()
self.value = value
self.attr = attr
class Subscript(Expr):
_children = ['value', 'index']
def __init__(self, value: Expr, index: Expr):
super().__init__()
self.value = value
self.index = index
class Name(Expr):
def __init__(self, id_str: str):
super().__init__()
self.id = id_str
class Dict(Expr):
_children = ['keys', 'values']
def __init__(self, keys: ListT[Name], values: ListT[Expr]):
super().__init__()
self.keys = keys
self.values = values
class List(Expr):
_children = ['elements']
def __init__(self, elements: ListT[Expr]):
super().__init__()
self.elements = elements
class Tuple(Expr):
_children = ['elements']
def __init__(self, elements: ListT[Expr]):
super().__init__()
self.elements = elements
class Module(Node):
_children = ['stmts']
def __init__(self, stmts: ListT[Stmt]):
super().__init__()
self.stmts = stmts
class StructDef(Node):
_children = ['body']
def __init__(self, name: str, body: ListT[Stmt]):
super().__init__()
self.name = name
self.body = body
class ContractDef(Node):
_children = ['body']
def __init__(self, name: str, body: ListT[Stmt]):
super().__init__()
self.name = name
self.body = body
class EventDef(Node):
"""
Struct like event declaration
"""
_children = ['body']
def __init__(self, name: str, body: ListT[Stmt]):
super().__init__()
self.name = name
self.body = body
class Arg(Node, AllowedInGhostCode):
_children = ['annotation', 'default']
def __init__(self, name: str, annotation: Expr, default: OptionalT[Expr]):
super().__init__()
self.name = name
self.annotation = annotation
self.default = default
class Decorator(Node, AllowedInGhostCode):
_children = ['args']
def __init__(self, name: str, args: ListT[Expr]):
super().__init__()
self.name = name
self.args = args
class FunctionDef(Stmt, AllowedInGhostCode):
_children = ['args', 'body', 'decorators', 'returns']
def __init__(self, name: str, args: ListT[Arg], body: ListT[Stmt],
decorators: ListT[Decorator], returns: OptionalT[Expr]):
super().__init__()
self.name = name
self.args = args
self.body = body
self.decorators = decorators
self.returns = returns
self.is_lemma = False
class FunctionStub(Stmt, AllowedInGhostCode):
_children = ['args']
def __init__(self, name: str, args: ListT[Arg], returns: OptionalT[Expr]):
super().__init__()
self.name = name
self.args = args
self.returns = returns
class Return(Stmt):
_children = ['value']
def __init__(self, value: OptionalT[Expr]):
super().__init__()
self.value = value
class Assign(Stmt):
_children = ['target', 'value']
def __init__(self, target: Expr, value: Expr):
super().__init__()
self.target = target
self.value = value
class AugAssign(Stmt):
_children = ['target', 'value']
def __init__(self, target: Expr, op: ArithmeticOperator, value: Expr):
super().__init__()
self.target = target
self.op = op
self.value = value
class AnnAssign(Stmt):
_children = ['target', 'annotation', 'value']
def __init__(self, target: Name, annotation: Expr, value: Expr):
super().__init__()
self.target = target
self.annotation = annotation
self.value = value
class For(Stmt):
_children = ['target', 'iter', 'body']
def __init__(self, target: Name, iter_expr: Expr, body: ListT[Stmt]):
super().__init__()
self.target = target
self.iter = iter_expr
self.body = body
class If(Stmt, AllowedInGhostCode):
_children = ['test', 'body', 'orelse']
def __init__(self, test: Expr, body: ListT[Stmt], orelse: ListT[Stmt]):
super().__init__()
self.test = test
self.body = body
self.orelse = orelse
class Log(Stmt, AllowedInGhostCode):
_children = ['body']
def __init__(self, body: Expr):
super().__init__()
self.body = body
class Ghost(Stmt, AllowedInGhostCode):
_children = ['body']
def __init__(self, body: ListT[Stmt]):
super().__init__()
self.body = body
class Raise(Stmt, AllowedInGhostCode):
_children = ['msg']
def __init__(self, msg: Expr):
super().__init__()
self.msg = msg
class Assert(Stmt, AllowedInGhostCode):
_children = ['test', 'msg']
def __init__(self, test: Expr, msg: OptionalT[Expr]):
super().__init__()
self.test = test
self.msg = msg
self.is_lemma = False
class Alias(Node):
def __init__(self, name: str, asname: OptionalT[str]):
super().__init__()
self.name = name
self.asname = asname
class Import(Stmt):
_children = ['names']
def __init__(self, names: ListT[Alias]):
super().__init__()
self.names = names
class ImportFrom(Stmt):
_children = ['names']
def __init__(self, module: OptionalT[str], names: ListT[Alias], level: int):
super().__init__()
self.module = module
self.names = names
self.level = level
class ExprStmt(Stmt, AllowedInGhostCode):
_children = ['value']
def __init__(self, value: Expr):
super().__init__()
self.value = value
class Pass(Stmt, AllowedInGhostCode):
pass
class Break(Stmt):
pass
class Continue(Stmt):
pass
def compare_nodes(first_node: Node, second_node: Node) -> bool:
"""
Similar as vyper/ast/nodes.py:compare_nodes
"""
if not isinstance(first_node, type(second_node)):
return False
for field_name in (i for i in first_node.children):
left_value = getattr(first_node, field_name, None)
right_value = getattr(second_node, field_name, None)
# compare types instead of isinstance() in case one node class inherits the other
if type(left_value) is not type(right_value):
return False
if isinstance(left_value, list):
if next((i for i in zip(left_value, right_value) if not compare_nodes(*i)), None):
return False
elif isinstance(left_value, Node):
if not compare_nodes(left_value, right_value):
return False
elif left_value != right_value:
return False
return True | 2vyper | /2vyper-0.3.0.tar.gz/2vyper-0.3.0/src/twovyper/ast/ast_nodes.py | ast_nodes.py |
Subsets and Splits