nt25 0.1.0__tar.gz

nt25-0.1.0/.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+end_of_line = lf
+charset = utf-8
+max_line_length = 88

nt25-0.1.0/.flake8

@@ -0,0 +1,2 @@
+[flake8]
+indent-size = 2

nt25-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish
+
+on:
+  push:
+    tags: ["*"]
+
+jobs:
+  pypi-publish:
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write
+
+    environment:
+      name: publish
+      url: https://pypi.org/p/ntpy
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup
+        uses: astral-sh/setup-uv@v6
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

nt25-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+uv.lock
+.venv
+
+ds/
+*.csv
+*.xlsx

nt25-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

nt25-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: nt25
+Version: 0.1.0
+Summary: Neo's Tools of Python
+Requires-Python: >=3.13
+Requires-Dist: matplotlib>=3.10.6
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: scikit-learn>=1.7.1
+Requires-Dist: sympy>=1.14.0
+Description-Content-Type: text/markdown
+
+# NT.py
+
+Neo's Tools of Python
+
+## plans
+
+- [x] fio
+- [x] calc
+- [ ] draw with 3d
+
+## scripts from init
+
+```sh
+uv init
+uv run ntpy
+```
+
+## fun
+
+$$
+\sqrt{-1},2^{3},\sum,\pi
+$$

nt25-0.1.0/README.md

@@ -0,0 +1,22 @@
+# NT.py
+
+Neo's Tools of Python
+
+## plans
+
+- [x] fio
+- [x] calc
+- [ ] draw with 3d
+
+## scripts from init
+
+```sh
+uv init
+uv run ntpy
+```
+
+## fun
+
+$$
+\sqrt{-1},2^{3},\sum,\pi
+$$

nt25-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "nt25"
+version = "0.1.0"
+description = "Neo's Tools of Python"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "matplotlib>=3.10.6",
+    "openpyxl>=3.1.5",
+    "pandas>=2.3.2",
+    "scikit-learn>=1.7.1",
+    "sympy>=1.14.0",
+]
+
+[project.scripts]
+ntpy = "ntpy.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

nt25-0.1.0/src/nt25/__init__.py

@@ -0,0 +1,7 @@
+import importlib.metadata as meta
+
+from .lib import fio, calc, draw
+from .lib.draw import DType
+
+__version__ = meta.version(str(__package__))
+__all__ = ('__version__', 'fio', 'calc', 'draw', 'DType')

nt25-0.1.0/src/nt25/lib/calc.py

@@ -0,0 +1,104 @@
+import re
+from typing import Iterable
+import numpy as np
+
+from sympy import symbols, Eq, solve
+
+from sklearn.metrics import r2_score as r2
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+
+
+def str2e(s) -> str:
+  return s if len(s) < 5 else f'{float(s):.4e}'
+
+
+def fl2el(fl) -> list[str]:
+  return list(map(lambda f: str2e(str(f)), fl))
+
+
+def poly(x, y, degree=2) -> Iterable:
+  return np.polyfit(x, y, degree).tolist()
+
+
+def polyResults(coef, x) -> Iterable:
+  return np.poly1d(coef)(x).tolist()
+
+
+def polyRoots(coef) -> Iterable:
+  return np.roots(coef).tolist()
+
+
+def xn2y(X, y, degree=2, output=False, foo='xn2y'):
+  poly = PolynomialFeatures(degree=degree, include_bias=False)
+
+  Xa = np.array(X)
+  if len(Xa.shape) == 1:
+    Xa = np.array([X])
+
+  x = Xa.T
+  xp = poly.fit_transform(x)
+
+  model = LinearRegression()
+  model.fit(xp, y)
+  # y1 = model.predict(xp)
+
+  coef = model.coef_
+  names = poly.get_feature_names_out().tolist()
+
+  eq = f'{model.intercept_:.4e} + '
+  for i in range(len(names)):
+    ex = names[i].replace('^', '**').replace(' ', '*')
+    eq += f"({coef[i]:.4e})*{ex} + "
+
+  eq = re.sub(r'x(\d+)', r'x[\1]', eq[:-3])
+  func = _genFunc(foo, 'x', eq)
+
+  y2 = [func(x[i]) for i in range(len(x))]
+  yr2 = r2(y, y2)
+
+  if output:
+    q = eq.replace(' + ', ' + \\\n\t') \
+        .replace('*x', ' * x').replace('e+00', '')
+
+    print(f'{foo}: degree = {degree}, R² = {yr2:.4%}\n  y = {q}\n')
+
+  return {
+      'func': func,
+      'r2': yr2,
+      'eq': eq,
+  }
+
+
+def _genFunc(name, args, expr):
+  local = {}
+  src = compile(f'def {name}({args}):\n\treturn {expr}', "<string>", "exec")
+  exec(src, {}, local)
+  return local[name]
+
+
+def solveEq(eq, output=False, foo='solve'):
+  (x0, x1, y) = symbols('x:2,y')
+  eq = re.sub(r'x\[(\d+)\]', r'x\1', eq)
+  solution = solve(Eq(eval(eq), y), x0)
+
+  real = []
+  for s in solution:
+    sol = str(s)
+    if 'I' in sol:
+      continue
+
+    func = _genFunc(foo, 'y, x1=0', sol)
+    s4e = re.sub(r'([-]?\d*\.\d+)', lambda m: str2e(m.group(0)), sol)
+
+    if output:
+      print(f'{foo}: {eq}\n  x0 = {s4e}\n')
+
+    real.append({
+        'org': eq,
+        'func': func,
+        'eq': sol,
+        'eq.4e': s4e,
+    })
+
+  return real

nt25-0.1.0/src/nt25/lib/draw.py

@@ -0,0 +1,141 @@
+from enum import Enum
+from random import sample
+
+import numpy as np
+
+from matplotlib.axes import Axes
+from matplotlib import pyplot as plot
+
+# import matplotlib.animation as animation
+
+
+FONTS = ['PingFang SC', 'Microsoft YaHei', 'Arial']
+COLORS = ['blue', 'red', 'orange', 'black', 'pink']
+
+
+def _getPlot(ref, pos, font='Roboto') -> Axes:
+  if 'figure' not in ref:
+    ref['figure'] = plot.figure()
+    plot.rcParams['font.sans-serif'] = [font] + FONTS
+    # plot.rcParams['font.sans-serif'] = ['Arial']
+    plot.rcParams['axes.unicode_minus'] = False
+
+  if 'subplot' not in ref:
+    ref['subplot'] = {}
+
+  fig = ref['figure']
+  sub = ref['subplot']
+
+  if pos not in sub:
+    sub[pos] = fig.add_subplot(pos)
+
+  return sub[pos]
+
+
+def _genList(refer: list, length, random=False):
+  r = []
+
+  while len(r) < length:
+    r += sample(refer, len(refer)) if random else refer
+
+  return r[:length]
+
+
+def _coord(ref, X, Y, color, pos, randomColor, method, *args, **kwargs):
+  Xa = np.array(X)
+  Ya = np.array(Y)
+
+  if Xa.shape != Ya.shape:
+    print(f"bad shape {Xa.shape} != {Ya.shape}")
+    return
+
+  count = 1
+  # count = Xa.shape[0] if len(Xa.shape) > 1 else 1
+
+  if len(Xa.shape) > 1:
+    count = Xa.shape[0]
+    if count == 1:
+      X = X[0]
+      Y = Y[0]
+
+  if color is None:
+    color = _genList(COLORS, count, random=randomColor)
+
+  if count == 1:
+    if isinstance(color, (list, tuple)):
+      color = color[0]
+  elif len(color) != count:
+    print(f"bad color.len {len(color)} != {count}")
+    return
+
+  if pos is None:
+    pos = [111] * count
+
+  if count == 1:
+    if isinstance(pos, (list, tuple)):
+      pos = pos[0]
+  elif len(pos) != count:
+    print(f"bad pos.len {len(pos)} != {count}")
+    return
+
+  if count > 1 and isinstance(pos, list):
+    for i in range(count):
+      p = _getPlot(ref, pos[i])
+      method(p, X[i], Y[i], color=color[i], *args, **kwargs)
+  else:
+    p = _getPlot(ref, pos)
+    method(p, X, Y, color=color, *args, **kwargs)
+
+  return ref
+
+
+class DType(Enum):
+  scatter = 1,
+  line = 2,
+  func = 3,
+
+
+def d2d(type=DType.scatter, X=None, Y=None, Func=None, min=None, max=None,
+        ref=None, color=None, pos=None, randomColor=False, show=False,
+        *args, **kwargs):
+  if ref is None:
+    ref = {}
+
+  match type:
+    case DType.scatter:
+      func = Axes.scatter
+
+    case DType.line:
+      func = Axes.plot
+
+    case DType.func:
+      func = Axes.plot
+      if Func is not None and min is not None and max is not None:
+        if callable(Func):
+          Func = (Func,)
+
+        X = []
+        Y = []
+
+        for i in range(len(Func)):
+          dx = np.linspace(min[i] if isinstance(min, (list, tuple)) else min,
+                           max[i] if isinstance(max, (list, tuple)) else max)
+
+          X.append(dx)
+          Y.append([Func[i]([x]) for x in dx])
+
+  ref = _coord(ref, X, Y, color=color, pos=pos, randomColor=randomColor,
+               method=func, *args, **kwargs)
+
+  if show:
+    plot.show()
+
+  return ref
+
+
+def show():
+  plot.show()
+
+
+def clear():
+  plot.clf()

nt25-0.1.0/src/nt25/lib/fio.py

@@ -0,0 +1,116 @@
+import os
+import csv
+from typing import Iterable
+
+# import openpyxl
+import pandas as pd
+
+ENCODINGS = ['utf-8', 'utf-8-sig', 'gbk']
+
+
+def _switchEnc(foo, encoding=None, *args, **kwargs):
+  result = None
+
+  if encoding is None:
+    for enc in ENCODINGS if os.name != 'nt' else reversed(ENCODINGS):
+      try:
+        result = foo(encoding=enc, *args, **kwargs)
+        break
+      except Exception as e:
+        print(e)
+
+  else:
+    result = foo(encoding=encoding, *args, **kwargs)
+
+  return result
+
+
+def _getCSV(file, width, startLine, startCol, encoding):
+  f = open(file, encoding=encoding)
+  cf = csv.reader(f)
+
+  count = 0
+  result = [[] for _ in range(width - startCol)]
+
+  for line in cf:
+    if count >= startLine:
+      maxWidth = len(line)
+      for i in range(startCol, width):
+        x = line[i].strip() if maxWidth > i else ''
+
+        try:
+          result[i - startCol].append(float(x))
+        except ValueError:
+          result[i - startCol].append(x)
+
+    count += 1
+
+  f.close()
+  return result
+
+
+def _getCSV2(file, encoding=None, colsInline=True):
+  df = pd.read_csv(file, encoding=encoding)
+
+  row = df.to_numpy()
+  r = row.T if colsInline else row
+
+  return r.tolist()
+
+
+def getCSV(file, width=2, startLine=1, startCol=0, encoding=None):
+  return _switchEnc(foo=_getCSV, encoding=encoding, file=file,
+                    width=width, startLine=startLine, startCol=startCol)
+
+
+def getCSV2(file, encoding=None):
+  return _switchEnc(foo=_getCSV2, encoding=encoding, file=file)
+
+
+def saveCSV(data, file, encoding=None, colsInline=True):
+  if encoding is None:
+    encoding = 'utf-8'
+
+  with open(file, 'w', newline='', encoding=encoding) as f:
+    content = []
+
+    for d in data:
+      if isinstance(d, str):
+        content.append(data[d])
+      elif isinstance(d, Iterable):
+        content.append(d)
+
+    if colsInline:
+      content = list(map(list, zip(*content)))
+
+    cf = csv.writer(f)
+    cf.writerows(content)
+
+
+def saveCSV2(data, file, encoding=None, float_format=None, colsInline=True):
+  if data is not None:
+    df = pd.DataFrame(data)
+
+    if colsInline:
+      df = df.T
+
+    df.to_csv(file, index=False, encoding=encoding, float_format=float_format)
+
+
+def getXlsx(file, sheet=0, colsInLine=True):
+  df = pd.read_excel(file, sheet_name=sheet)
+
+  row = df.to_numpy()
+  r = row.T if colsInLine else row
+
+  return r.tolist()
+
+
+def saveXlsx(data, file, colsInline=True):
+  if data is not None:
+    df = pd.DataFrame(data)
+
+    if colsInline:
+      df = df.T
+
+    df.to_excel(file, index=False)

nt25-0.1.0/src/nt25/main.py

@@ -0,0 +1,54 @@
+from ntpy import fio, calc, draw, DType, __version__
+
+# import timeit
+# timeit.timeit('', number=100, globals=globals())
+
+
+def main():
+  print(f"Hello from {__package__}({__version__})! ")
+
+  # [Neo] some file I/O: csv, xlsx
+  fio.saveCSV({
+      'Name': ['Alice', 'Bob', 'Charlie'],
+      'Age': [25.2, 30, 35],
+      'City': ['New York', 'Los Angeles', 'Chicago']
+  }, "out.csv", colsInline=False)
+
+  data = fio.getXlsx('ds/qs.xlsx')
+  fio.saveCSV(data, "out2.csv")
+
+  h = data[0]
+  s = data[1]
+  v = data[2]
+
+  # [Neo] some poly calculates
+  c = calc.poly(h, v)
+  ce = calc.fl2el(c)
+  print(c, ce)
+
+  foo = calc.xn2y(h, v, degree=3, output=True)
+  bar = calc.solveEq(foo['eq'])
+
+  func = foo['func']
+  bfunc = bar[0]['func']
+
+  Y = range(1000, 2000, 200)
+  X = [bfunc(y) for y in Y]
+
+  # [Neo] draw 2d with types
+  ref = {}
+  draw.d2d(X=h, Y=v, ref=ref)
+  draw.d2d(type=DType.scatter, X=X, Y=Y, ref=ref, color='red', s=120)
+  draw.d2d(type=DType.func, Func=func, min=40, max=60, ref=ref, color='red')
+  draw.show()
+
+  # [Neo] and 3d calcs
+  foo = calc.xn2y([h, s], v, degree=3, output=False)
+  bar = calc.solveEq(foo['eq'], output=True)
+
+  if len(bar) > 0:
+    print('s> 750, 1.5 ~', bar[0]['func'](y=750, x1=1.5))
+
+
+if __name__ == "__main__":
+  main()